如何在corda事务中使用响应程序inputsStatesAndRef？

我正在尝试构建一个corda应用程序来训练porpus。在这个申请中，我需要转学 一些硬币归新主人所有，保存这些硬币的州必须是唯一的，如果你有一个以前的硬币州，你需要对其进行演变。例如，如果有人向你转移300枚硬币，而你已经有200枚，你将把200枚硬币的状态演变为500枚硬币的新状态

我已经尝试创建其他子流来获取响应者对事务的输入，但没有成功。下面，你们可以看到我的请求和响应流，而不必处理我上面提到的这种情况。你们能知道我该怎么处理这种情况吗

非常感谢你们，很抱歉我的文章中出现了一些英语问题

    @InitiatingFlow
    @StartableByRPC
    class CoinTransferFlow(var amount: Double, val newOwner: Party) : FlowLogic<SignedTransaction>() {
        companion object {
            object GENERATING_TRANSACTION : ProgressTracker.Step("Generating transaction based on new BrunoCoin.")
            object VERIFYING_TRANSACTION : ProgressTracker.Step("Verifying contract constraints.")
            object SIGNING_TRANSACTION : ProgressTracker.Step("Signing transaction with our private key.")
            object GETTING_OTHER_SIGNATURES : ProgressTracker.Step("Gathering the counterparty's signature.") {
                override fun childProgressTracker() = CollectSignaturesFlow.tracker()
            }

            object FINALISING_TRANSACTION : ProgressTracker.Step("Obtaining notary signature and recording transaction.") {
                override fun childProgressTracker() = FinalityFlow.tracker()
            }

            fun tracker() = ProgressTracker(
                    GENERATING_TRANSACTION,
                    VERIFYING_TRANSACTION,
                    SIGNING_TRANSACTION,
                    GETTING_OTHER_SIGNATURES,
                    FINALISING_TRANSACTION
            )
        }

        override val progressTracker = tracker()

        @Suspendable
        override fun call(): SignedTransaction {
            val listMoneyStateAndRef = serviceHub.vaultService.queryBy(BrunoCoinState::class.java).states

            val notary = serviceHub.networkMapCache.notaryIdentities[0]

            progressTracker.currentStep = GENERATING_TRANSACTION
            var txBuilder = buildTransaction(listMoneyStateAndRef, notary)

            progressTracker.currentStep = VERIFYING_TRANSACTION

            txBuilder.verify(serviceHub)

            progressTracker.currentStep = SIGNING_TRANSACTION

            val signedTransaction = serviceHub.signInitialTransaction(txBuilder)

            progressTracker.currentStep = GETTING_OTHER_SIGNATURES


            progressTracker.currentStep = FINALISING_TRANSACTION

            val otherPartySession = initiateFlow(newOwner)
            otherPartySession.send(signedTransaction)
            return subFlow(FinalityFlow(signedTransaction, setOf(otherPartySession)))
        }

@InitiatingFlow
@星表
类CoinTransferFlow（var金额：Double，val新所有者：Party）：FlowLogic（）{
伴星{
生成事务的对象：ProgressTracker.Step（“基于新BrunoCoin生成事务”）
对象验证\u事务：ProgressTracker.Step（“验证契约约束”）
对象签名\u事务：ProgressTracker.Step（“使用我们的私钥对事务进行签名”）
获取其他签名的对象：ProgressTracker.Step（“收集交易对手的签名”）{
重写fun childProgressTracker（）=CollectSignaturesFlow.tracker（）
}
完成交易的对象：ProgressTracker.Step（“获取公证人签名并记录交易”）{
重写fun childProgressTracker（）=FinalityFlow.tracker（）
}
乐趣跟踪器（）=进度跟踪器(
生成一个事务，
验证您的交易，
签署交易，
获取其他签名，
完成交易
)
}
重写val progressTracker=tracker（）
@暂停
重写趣味调用（）：SignedTransaction{
val listMoneyStateAndRef=serviceHub.vaultService.queryBy（brunocinstate:：class.java）.states
val notary=serviceHub.networkMapCache.NotaryIdentity[0]
progressTracker.currentStep=生成\u事务
var txBuilder=buildTransaction（listMoneyStateAndRef，公证人）
progressTracker.currentStep=验证\u事务
txBuilder.verify（serviceHub）
progressTracker.currentStep=对交易进行签名
val signedTransaction=serviceHub.signInitialTransaction（txBuilder）
progressTracker.currentStep=获取其他签名
progressTracker.currentStep=完成交易
val otherPartySession=initiateFlow（新所有者）
otherPartySession.send（签名交易）
返回子流（FinalityFlow（signedTransaction，setOf（otherPartySession）））
}

@InitiatedBy（CoinTransferFlow:：class）
类TransferResponderFlow（val otherPartySession:FlowSession）：FlowLogic（）{
伴星{
对象验证交易：ProgressTracker.Step（“交易对手验证合同约束”）
对象完成交易：ProgressTracker.步骤（“交易对手完成交易”）
乐趣跟踪器（）=进度跟踪器(
验证您的交易，
完成交易
)
}
重写val progressTracker=tracker（）
@暂停
重写趣味调用（）：SignedTransaction{
fun verifyTx（sgdTx:SignedTransaction）=要求{
使用（sgdTx.tx.outputStates[0]为BrunocInstate）的“输出精度为tipo BrunocInstate”
val bCoinState=sgdTx.tx.outputStates[0]为BrunocInstate
使用（sgdTx.tx.outputStates[1]为Brunocontransferstate）的“输出2精度为tipo Brunocontransferstate”
val BCointTransferState=sgdTx.tx.outputState[1]为内部传输状态
使用（b coinstate.amount>0）的“Os valores propostos na transação Dever maior que 0”
&&B点转移状态（金额>0）
使用（bCoinState.amount==bCoinTransferState.amount）的“交易价格提议书”
}
val sgdTx=otherPartySession.receive（）.unwrap{it}
progressTracker.currentStep=验证\u事务
verifyTx（sgdTx）
progressTracker.currentStep=完成交易
返回子流（ReceiveFinalityFlow（otherPartySession/*，expectedTxId=txId*/）
}
}

addInputState添加引用的输入：

/** Adds an input [StateRef] to the transaction. */
open fun addInputState(stateAndRef: StateAndRef<*>) = apply {
    checkNotary(stateAndRef)
    inputs.add(stateAndRef.ref)
    inputsWithTransactionState.add(stateAndRef)
    resolveStatePointers(stateAndRef.state)
    return this
}

/**向事务添加输入[StateRef]*/
open fun addInputState（stateAndRef:stateAndRef）=应用{
支票公证人（州）
输入。添加（stateAndRef.ref）
inputsWithTransactionState.add（stateAndRef）
resolveStatePointers（stateAndRef.state）
还这个
}

请参见一个示例：

/** Adds an input [StateRef] to the transaction. */
open fun addInputState(stateAndRef: StateAndRef<*>) = apply {
    checkNotary(stateAndRef)
    inputs.add(stateAndRef.ref)
    inputsWithTransactionState.add(stateAndRef)
    resolveStatePointers(stateAndRef.state)
    return this
}