Corda Tokens SDK and Accounts

@InitiatingFlow
@StartableByRPC
class MoveTokenOnSameNode(private val holderAccountName:String,
                          private val recipientAccountName:String,
                          private val amount: Long,
                          private val currency: String) : FlowLogic<String>() {
    @Suspendable
    override fun call():String {
        
        //Token holder Account
        val holderInfo = accountService.accountInfo(holderAccountName)[0].state.data
        val holderAccount = subFlow(RequestKeyForAccount(holderInfo))
        
        //Token recipient Account
        val recipientInfo = accountService.accountInfo(recipientAccountName).single().state.data
        val recipientAccount = subFlow(RequestKeyForAccount(recipientInfo))
        
        // notary
        val notary = serviceHub.networkMapCache.notaryIdentities.single() 
        
        // METHOD 1
        // making transaction
        val txbuilder = TransactionBuilder(notary)
        
        // getting current token
        val amount = Amount(amount, getInstance(currency))
        val partyAndAmount = PartyAndAmount(recipientAccount, amount)
        val payMoneyCriteria = QueryCriteria.VaultQueryCriteria(externalIds = listOf(holderInfo.identifier.id),
                                                                status = Vault.StateStatus.UNCONSUMED
                                                               )
        
        //call utility function to move the fungible token from holder to recipient account
        addMoveFungibleTokens(txbuilder, serviceHub, listOf(partyAndAmount), holderAccount, payMoneyCriteria)
        
        //self sign the transaction. note : the host party will first self sign the transaction.
        val selfSignedTx = serviceHub.signInitialTransaction(txbuilder, listOf(ourIdentity.owningKey))
        
        //establish sessions with holder and recipient. to establish session get the host name from accountinfo object
        val holderSession = initiateFlow(holderInfo.host)
        val recipientSession = initiateFlow(recipientInfo.host)
        
        //Note: though buyer and seller are on the same node still 
        //we will have to call CollectSignaturesFlow as the signer is not a Party but an account.
        val fulySignedTx = subFlow(CollectSignaturesFlow(selfSignedTx, listOf(holderSession, recipientSession)))
        
        //call ObserverAwareFinalityFlow for finality
        val stx = subFlow<SignedTransaction>(ObserverAwareFinalityFlow(fulySignedTx, listOf(holderSession, recipientSession)))
        return ("Tokens have moved to $holderAccountName"+ "ntxID: " + stx.id)
    }
}

@InitiatedBy(MoveTokenOnSameNode::class)
class MoveTokenOnSameNodeResponder(val counterpartySession: FlowSession) : FlowLogic<SignedTransaction>() {
    @Suspendable
    override fun call():SignedTransaction {subFlow(object : SignTransactionFlow(counterpartySession) {
            @Throws(FlowException::class)
            override fun checkTransaction(stx: SignedTransaction) {
                // Custom Logic to validate transaction.
            }
        })
        return subFlow(ReceiveFinalityFlow(counterpartySession))
    }
}

@InitiatingFlow
@StartableByRPC
class MoveTokenToOtherNode(private val holderAccountName:String,
                           private val recipientAccountName:String,
                           private val amount: Long,
                           private val currency: String) : FlowLogic<String>() {@Suspendable
    override fun call():String {
        //holder Account
        val holderInfo = accountService.accountInfo(holderAccountName)[0].state.data
        val holderAccount = subFlow(RequestKeyForAccount(holderInfo))
        
        //recipient Account
        val recipientInfo = accountService.accountInfo(recipientAccountName).single().state.data
        val recipientAccount = subFlow(RequestKeyForAccount(recipientInfo))
        
        // making recipient session
        val recipientSession = initiateFlow(recipientInfo.host)
        recipientSession.send(holderAccountName)
        recipientSession.send(recipientAccountName)
        
        //holder will create generate a move tokens state and send this state
        val amount = Amount(amount, getInstance(currency))
        
        //holder Query for token balance.
        val queryCriteria = heldTokenAmountCriteria(getInstance(currency), holderAccount).and(sumTokenCriteria())
        val sum = serviceHub.vaultService.queryBy(FungibleToken::class.java, queryCriteria).component5()
        if (sum.size == 0) throw FlowException(
            "$holderAccountName has 0 token balance. Please ask the Bank to issue some cash.") 
        else {
            val tokenBalance = sum[0] as Long
            if (tokenBalance < this.amount) throw FlowException(
                "Available token balance of $holderAccountName is less than you have. 
                 Please ask the Bank to issue some cash if you wish to move tokens ")
        }
        //the tokens to move to new account which is the recipient account
        val partyAndAmount:Pair<AbstractParty, Amount<TokenType>> = Pair(recipientAccount, amount)
        
        //let's use the DatabaseTokenSelection to get the tokens from the db
        val tokenSelection = DatabaseTokenSelection(serviceHub, 
                                                    MAX_RETRIES_DEFAULT,
                                                    RETRY_SLEEP_DEFAULT, 
                                                    RETRY_CAP_DEFAULT, 
                                                    PAGE_SIZE_DEFAULT
                                                   )
        val inputsAndOutputs = tokenSelection.generateMove(Arrays.asList(partyAndAmount), 
                                                           holderAccount, 
                                                           TokenQueryBy(), 
                                                           runId.uuid
                                                          )
                
        //send the generated inputsAndOutputs to the recipient
        subFlow(SendStateAndRefFlow(recipientSession, inputsAndOutputs.first))
        recipientSession.send(inputsAndOutputs.second)
                
        //created by the above token move method for the holder.
        val signers: MutableList<AbstractParty> = ArrayList()
        signers.add(holderAccount)
        signers.add(recipientAccount)val inputs = inputsAndOutputs.first
        for ((state) in inputs) {
            signers.add(state.data.holder)
        }
                
        //Sync our associated keys with the conterparties.
        subFlow(SyncKeyMappingFlow(recipientSession, signers))
                
        //this is the handler for synckeymapping called by seller. seller must also have created some keys not known to us
        subFlow(SyncKeyMappingFlowHandler(recipientSession))
                
        //recieve the data from counter session in tx formatt.
        subFlow(object : SignTransactionFlow(recipientSession) {
            @Throws(FlowException::class)
            override fun checkTransaction(stx: SignedTransaction) {
                // Custom Logic to validate transaction.
            }
        })
        val stx = subFlow(ReceiveFinalityFlow(recipientSession))
        return ("Tokens have moved to $holderAccountName"+ "ntxID: "+stx.id)
    }
}
                
@InitiatedBy(MoveTokenToOtherNode::class)
class MoveTokenToOtherNodeResponder(val otherSide: FlowSession) : FlowLogic<SignedTransaction>() {
    @Suspendable
    override fun call():SignedTransaction {
        
        //get all the details from the recipient
        val holderAccountName: String = otherSide.receive(String::class.java).unwrap { it }
        val recipientAccountName: String = otherSide.receive(String::class.java).unwrap{ it }
        val inputs = subFlow(ReceiveStateAndRefFlow<FungibleToken>(otherSide))
        val moneyReceived: List<FungibleToken> = otherSide.receive(List::class.java).unwrap{ it } as List<FungibleToken>
        
        //call SyncKeyMappingHandler for SyncKey Mapping called at holder side
        subFlow(SyncKeyMappingFlowHandler(otherSide))
        
        //Get holder and recipient account info
        val holderAccountInfo = accountService.accountInfo(holderAccountName)[0].state.data
        val recipientAccountInfo = accountService.accountInfo(recipientAccountName)[0].state.data
        
        //Generate new keys for buyers and sellers
        val holderAccount = subFlow(RequestKeyForAccount(holderAccountInfo))
        val recipientAccount = subFlow(RequestKeyForAccount(recipientAccountInfo))
        val notary = serviceHub.networkMapCache.notaryIdentities.single()val txBuilder = TransactionBuilder(notary)
        
        addMoveTokens(txBuilder, inputs, moneyReceived)
        
        //add signers
        val signers: MutableList<AbstractParty> = ArrayList()
        signers.add(holderAccount)
        signers.add(recipientAccount)
        for ((state) in inputs) {
            signers.add(state.data.holder)
        }
        
        //sync keys with holder, again sync for similar members
        subFlow(SyncKeyMappingFlow(otherSide, signers))
        
        val commandWithPartiesList: List<CommandWithParties<CommandData>> = txBuilder.toLedgerTransaction(serviceHub).commands
        val mySigners: MutableList<PublicKey> = ArrayList()
        commandWithPartiesList.map {
            val signer = (serviceHub.keyManagementService.filterMyKeys(it.signers) as ArrayList<PublicKey>)
            if(signer.size >0){
                mySigners.add(signer[0]) }
        }
        val selfSignedTransaction = serviceHub.signInitialTransaction(txBuilder, mySigners)
        val fullySignedTx = subFlow(CollectSignaturesFlow(selfSignedTransaction, listOf(otherSide), mySigners))
        
        //call FinalityFlow for finality
        return subFlow(FinalityFlow(fullySignedTx, Arrays.asList(otherSide)))
    }
}

CollectSignaturesFlowが呼び出された際に、以下のエラーが発生。
java.lang.IllegalArgumentException: The Initiator of CollectSignaturesFlow must have signed the transaction.
（CollectSignaturesFlow のイニシエータは、トランザクションに署名していなければならない）

val isSameNode = recipientSession.counterparty.equals(ourIdentity)
 val stx = when(isSameNode){
            true -> {
                        val fullySignedTx = subFlow(CollectSignaturesFlow(selfSignedTx, 
                                                                          listOf(holderSession,recipientSession), 
                                                                          signers)
                                                   )
                subFlow<SignedTransaction>(ObserverAwareFinalityFlow(fullySignedTx, 
                                                                     listOf(recipientSession,observerSession)
                                                                    )
                                          )
            }
            else -> {
                val fullySignedTx = subFlow(CollectSignaturesFlow(selfSignedTx, 
                                                                  listOf(recipientSession), 
                                                                  signers
                                                                 )
                                           )
                
               subFlow<SignedTransaction>(ObserverAwareFinalityFlow(fullySignedTx, 
                                                                    listOf(recipientSession,observerSession)
                                                                   )
                                         )listOf(recipientSession))
                )
            }
}

Caused by: java.io.NotSerializableException: Described type with descriptor net.corda:vlc3i8lJnO7K1i2g0g0+aA== was expected to be of type class net.corda.core.transactions.SignedTransaction but was class com.r3.corda.lib.tokens.workflows.internal.flows.finality.TransactionRole

Caused by: java.io.NotSerializableException: Described type with descriptor net.corda:vlc3i8lJnO7K1i2g0g0+aA== was expected to be of type class net.corda.core.transactions.SignedTransaction but was class com.r3.corda.lib.tokens.workflows.internal.flows.finality.TransactionRole