如何检索corda中要使用的状态

我需要在Corda中更新一个状态，在它创建之后。我正在为此使用LinearState类，它有一个UniqueIdentifier类型的LinearID字段。我面临的问题是如何将要使用的状态的唯一标识符传递给节点终端中UpdateFlow的构造函数。我的更新流的代码如下所示：

@InitiatingFlow
@StartableByRPC
public static class UpdateOffer extends FlowLogic<SignedTransaction> {
        private final ProgressTracker.Step GENERATING_TRANSACTION = new ProgressTracker.Step("Generating transaction.");
        private final ProgressTracker.Step ADDING_NEW_OFFER = new ProgressTracker.Step("Adding the New Offer State.");
        private final ProgressTracker.Step VERIFYING_TRANSACTION = new ProgressTracker.Step("Verifying contract constraints.");
        private final ProgressTracker.Step SIGNING_TRANSACTION = new ProgressTracker.Step("Signing transaction with our private key.");
        private final ProgressTracker.Step GATHERING_SIGS = new ProgressTracker.Step("Gathering the counterparty's signature.") {
            @Override
            public ProgressTracker childProgressTracker() {
                return CollectSignaturesFlow.Companion.tracker();
            }
        };
        private final ProgressTracker.Step FINALISING_TRANSACTION = new ProgressTracker.Step("Obtaining notary signature and recording transaction.") {
            @Override
            public ProgressTracker childProgressTracker() {
                return FinalityFlow.Companion.tracker();
            }
        };

        private final ProgressTracker progressTracker = new ProgressTracker(
                GENERATING_TRANSACTION,
                ADDING_NEW_OFFER,
                VERIFYING_TRANSACTION,
                SIGNING_TRANSACTION,
                GATHERING_SIGS,
                FINALISING_TRANSACTION
        );


        @Override
        public ProgressTracker getProgressTracker() {
            return progressTracker;
        }

        //Class Variables
        private final UniqueIdentifier linearID;
        private final String sender;
        private final String receiver;
        private final String policyID;
        private final double faceValue;
        private final double offeredAmount;

        public UpdateOffer(UniqueIdentifier linearID, String sender, String receiver, String policyID, double faceValue, double offeredAmount) {
            this.linearID = linearID;
            this.sender = sender;
            this.receiver = receiver;
            this.policyID = policyID;
            this.faceValue = faceValue;
            this.offeredAmount = offeredAmount;
        }

        @Override
        public SignedTransaction call() throws FlowException {
            List<UUID> listOfLinearIds = new ArrayList<>();
            listOfLinearIds.add(linearID.getId());
            QueryCriteria queryCriteria = new QueryCriteria.LinearStateQueryCriteria(null, listOfLinearIds);

            // 2. Get a reference to the inputState data that we are going to settle.
            Vault.Page results = getServiceHub().getVaultService().queryBy(OfferState.class, queryCriteria);
            StateAndRef inputStateAndRefToTransfer = (StateAndRef) results.getStates().get(0);
            OfferState inputStateToTransfer = (OfferState) inputStateAndRefToTransfer.getState().getData();


            AccountService accountService = getServiceHub().cordaService(KeyManagementBackedAccountService.class);
            //Owner Account
            AccountInfo lspAccountInfo = accountService.accountInfo(sender).get(0).getState().getData();
            PublicKey lspKey = subFlow(new NewKeyForAccount(lspAccountInfo.getIdentifier().getId())).getOwningKey();
            AnonymousParty lspAccount = subFlow(new RequestKeyForAccount(lspAccountInfo));

            //Insurance Company Account
            AccountInfo sellerAccountInfo = accountService.accountInfo(receiver).get(0).getState().getData();
            AnonymousParty sellerAccount = subFlow(new RequestKeyForAccount(sellerAccountInfo));

            final Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
            final OfferState output = new OfferState(inputStateToTransfer.getLinearId(), lspAccount,sellerAccount,policyID,faceValue,offeredAmount, true);

            progressTracker.setCurrentStep(GENERATING_TRANSACTION);
            TransactionBuilder builder = new TransactionBuilder(notary);

            progressTracker.setCurrentStep(ADDING_NEW_OFFER);
            builder.addInputState(inputStateAndRefToTransfer);
            builder.addOutputState(output,OfferContract.ID);
            builder.addCommand(new OfferContract.Commands.Send(), Arrays.asList(lspKey,sellerAccount.getOwningKey()));

            progressTracker.setCurrentStep(SIGNING_TRANSACTION);
            builder.verify(getServiceHub());
            SignedTransaction locallySignedTx = getServiceHub().signInitialTransaction(builder,Arrays.asList(getOurIdentity().getOwningKey(),lspKey));

            progressTracker.setCurrentStep(GATHERING_SIGS);
            FlowSession session  = initiateFlow(sellerAccountInfo.getHost());
            List<TransactionSignature> accountToMoveToSignature = (List<TransactionSignature>) subFlow(new CollectSignatureFlow(locallySignedTx,
                    session,sellerAccount.getOwningKey()));
            SignedTransaction signedByCounterParty = locallySignedTx.withAdditionalSignatures(accountToMoveToSignature);

            progressTracker.setCurrentStep(FINALISING_TRANSACTION);
            return subFlow(new FinalityFlow(signedByCounterParty, session));
        }
 }

@InitiatingFlow
@星表
公共静态类UpdateOffer扩展了FlowLogic{
private final ProgressTracker.Step GENERATING_TRANSACTION=new ProgressTracker.Step（“GENERATING TRANSACTION”）；
private final ProgressTracker.Step ADDING_NEW_OFFER=NEW ProgressTracker.Step（“ADDING the NEW OFFER State”）；
私有最终ProgressTracker.Step Verification_TRANSACTION=new ProgressTracker.Step（“Verification contract constraints.”）；
private final ProgressTracker.Step SIGNING_TRANSACTION=new ProgressTracker.Step（“使用我们的私钥对事务进行签名”）；
private final ProgressTracker.Step GATHERING_SIGS=新ProgressTracker.Step（“收集交易对手的签名”）{
@凌驾
公共ProgressTracker childProgressTracker（）{
返回CollectSignatureFlow.Companion.tracker（）；
}
};
private final ProgressTracker.Step Finaling_TRANSACTION=new ProgressTracker.Step（“获得公证人签名并记录交易”）{
@凌驾
公共ProgressTracker childProgressTracker（）{
返回FinalityFlow.Companion.tracker（）；
}
};
private final ProgressTracker ProgressTracker=新ProgressTracker(
生成一个事务，
添加新的报价，
验证您的交易，
签署交易，
收集信号，
完成交易
);
@凌驾
公共ProgressTracker getProgressTracker（）{
返回进程跟踪器；
}
//类变量
专用最终唯一标识符；
私有最终字符串发送器；
专用最终字符串接收器；
私有最终字符串policyID；
私人最终双面价值；
私人最终双重报价金额；
公共更新提供程序（UniqueIdentifier linearID、字符串发送方、字符串接收方、字符串policyID、double faceValue、double offeredAmount）{
this.linearID=linearID；
this.sender=发送方；
this.receiver=接收器；
this.policyID=policyID；
this.faceValue=faceValue；
this.offeredAmount=offeredAmount；
}
@凌驾
public SignedTransaction调用（）引发流异常{
List listOfLinearIds=new ArrayList（）；
添加（linearID.getId（））；
QueryCriteria QueryCriteria=新的QueryCriteria.LinearStateQueryCriteria（null，listOfLinearIds）；
//2.获取我们将要结算的inputState数据的引用。
Vault.Page results=getServiceHub（）.getVaultService（）.queryBy（OfferState.class，queryCriteria）；
StateAndRef inputStateAndRefToTransfer=（StateAndRef）results.getStates（）.get（0）；
OfferState inputStateToTransfer=（OfferState）InputStateAndRefotTransfer.getState（）.getData（）；
AccountService AccountService=getServiceHub（）.cordaService（KeyManagementBackedAccountService.class）；
//所有者帐户
AccountInfo lspAccountInfo=accountService.AccountInfo（发送方）.get（0.getState（）.getData（）；
PublicKey lspKey=subFlow（NewKeyForAccount（lspAccountInfo.getIdentifier（）.getId（））.getOwningKey（）；
AnonymousParty lspAccount=子流（新RequestKeyForAccount（lspAccountInfo））；
//保险公司帐户
AccountInfo sellerAccountInfo=accountService.AccountInfo（接收方）.get（0.getState（）.getData（）；
AnonymousParty sellerAccount=子流（新RequestKeyForAccount（sellerAccountInfo））；
最终参与方公证人=getServiceHub（）.getNetworkMapCache（）.getNotaryIdentities（）.get（0）；
最终报价状态输出=新报价状态（inputStateToTransfer.getLinearId（）、lspAccount、sellerAccount、policyID、faceValue、offeredAmount、true）；
progressTracker.setCurrentStep（生成_事务）；
TransactionBuilder=新TransactionBuilder（公证人）；
progressTracker.setCurrentStep（添加新的报价）；
builder.addInputState（InputState和FTOTransfer）；
builder.addOutputState（输出，OfferContract.ID）；
builder.addCommand（newoffercontract.Commands.Send（），Arrays.asList（lspKey，sellerAccount.getOwningKey（））；
progressTracker.setCurrentStep（签名\u事务）；
验证（getServiceHub（））；
SignedTransaction locallySignedTx=getServiceHub（）.signInitialTransaction（生成器，Arrays.asList（GetTouridentity（）.getOwningKey（），lspKey））；
progressTracker.setCurrentStep（收集信号）；
FlowSession session=initiateFlow（sellerAccountInfo.getHost（））；
List AccountToVetoSignature=（List）子流（新CollectSignatureFlow（locallySignedTx，
会话，sellerAccount.getOwningKey（））；
SignedTransaction SignedBy Accounter=本地LySignedTx.并附加签名（AccountToVetoSignature）；
progressTracker.setCurrentStep（完成_事务）；
返回子流（新的最终流（由交易对手签署，会话））；
}
}

有人能帮我吗？我被困在这里已经一个多星期了。

• 不要在流的构造函数中使用

  UniqueIdentifier

  输入参数，而是使用

  字符串

  ：

  公共更新提供程序（字符串linearID。。。
  

• 然后在流中，您可以这样查询：

  LinearStateQueryCriteri