Token Transfer between Accounts in r3 Corda - corda

Question

I have been trying to simulate a Banking System in r3 Corda. My project can be found Here .
The components of my system are:
Central Bank [ Issues tokens for other Banks ]
BankA
BankB
Notary
I can deploy and run the nodes in my system. Then I can create brunches under these Banks. The following commands have been run in BankA and BankB terminal respectively:
flow start CreateAndShareAccountFlow accountName: brunchA1, partyToShareAccountInfoToList: [CentralBank, BankA, BankB]
flow start CreateAndShareAccountFlow accountName: brunchB1, partyToShareAccountInfoToList: [CentralBank, BankB, BankA]
I can issue tokens for a brunch from the Central Bank's Terminal
start IssueCashFlow accountName : brunchA1 , currency : USD , amount : 80
Now , I try to move tokens from brunchA1 to brunchB1 using the following command.
start MoveTokensBetweenAccounts senderAccountName : brunchA1, rcvAccountName : brunchB1 , currency : USD , amount : 10
But after running the vaultQuery in BankA and BankB , it's not at all transferred!
run vaultQuery contractStateType : com.r3.corda.lib.tokens.contracts.states.FungibleToken
Here's the code snippet for my MoveTokensBetweenAccounts:
import co.paralleluniverse.fibers.Suspendable;
import com.r3.corda.lib.accounts.contracts.states.AccountInfo;
import com.r3.corda.lib.accounts.workflows.UtilitiesKt;
import com.r3.corda.lib.accounts.workflows.flows.RequestKeyForAccount;
import com.r3.corda.lib.tokens.contracts.states.FungibleToken;
import com.r3.corda.lib.tokens.contracts.types.TokenType;
import com.r3.corda.lib.tokens.selection.TokenQueryBy;
import com.r3.corda.lib.tokens.selection.database.config.DatabaseSelectionConfigKt;
import com.r3.corda.lib.tokens.selection.database.selector.DatabaseTokenSelection;
import com.r3.corda.lib.tokens.workflows.flows.move.MoveTokensUtilities;
import com.r3.corda.lib.tokens.workflows.utilities.QueryUtilities;
import kotlin.Pair;
import net.corda.core.contracts.Amount;
import net.corda.core.contracts.CommandData;
import net.corda.core.contracts.CommandWithParties;
import net.corda.core.contracts.StateAndRef;
import net.corda.core.flows.*;
import net.corda.core.identity.AbstractParty;
import net.corda.core.identity.AnonymousParty;
import net.corda.core.identity.Party;
import net.corda.core.node.services.vault.QueryCriteria;
import net.corda.core.transactions.SignedTransaction;
import net.corda.core.transactions.TransactionBuilder;
import java.security.PublicKey;
import java.util.*;
#StartableByRPC
#InitiatingFlow
public class MoveTokensBetweenAccounts extends FlowLogic<String> {
private final String senderAccountName;
private final String rcvAccountName;
private final String currency;
private final Long amount;
public MoveTokensBetweenAccounts(String senderAccountName, String rcvAccountName, String currency, Long amount) {
this.senderAccountName = senderAccountName;
this.rcvAccountName = rcvAccountName;
this.currency = currency;
this.amount = amount;
}
#Override
#Suspendable
public String call() throws FlowException {
AccountInfo senderAccountInfo = UtilitiesKt.getAccountService(this).accountInfo(senderAccountName).get(0).getState().getData();
AccountInfo rcvAccountInfo = UtilitiesKt.getAccountService(this).accountInfo(rcvAccountName).get(0).getState().getData();
AnonymousParty senderAccount = subFlow(new RequestKeyForAccount(senderAccountInfo)); AnonymousParty rcvAccount = subFlow(new RequestKeyForAccount(rcvAccountInfo));
Amount<TokenType> amount = new Amount(this.amount, getInstance(currency));
QueryCriteria queryCriteria = QueryUtilities.heldTokenAmountCriteria(this.getInstance(currency), senderAccount).and(QueryUtilities.sumTokenCriteria());
List<Object> sum = getServiceHub().getVaultService().queryBy(FungibleToken.class, queryCriteria).component5();
if(sum.size() == 0)
throw new FlowException(senderAccountName + " has 0 token balance. Please ask the Central Bank to issue some cash.");
else {
Long tokenBalance = (Long) sum.get(0);
if(tokenBalance < this.amount)
throw new FlowException("Available token balance of " + senderAccountName + " is less than the cost of the ticket. Please ask the Central Bank to issue some cash ");
}
Pair<AbstractParty, Amount<TokenType>> partyAndAmount = new Pair(rcvAccount, amount);
DatabaseTokenSelection tokenSelection = new DatabaseTokenSelection(
getServiceHub(),
DatabaseSelectionConfigKt.MAX_RETRIES_DEFAULT,
DatabaseSelectionConfigKt.RETRY_SLEEP_DEFAULT,
DatabaseSelectionConfigKt.RETRY_CAP_DEFAULT,
DatabaseSelectionConfigKt.PAGE_SIZE_DEFAULT
);
Pair<List<StateAndRef<FungibleToken>>, List<FungibleToken>> inputsAndOutputs =
tokenSelection.generateMove(Arrays.asList(partyAndAmount), senderAccount, new TokenQueryBy(), getRunId().getUuid());
Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
TransactionBuilder transactionBuilder = new TransactionBuilder(notary);
MoveTokensUtilities.addMoveTokens(transactionBuilder, inputsAndOutputs.getFirst(), inputsAndOutputs.getSecond());
Set<PublicKey> mySigners = new HashSet<>();
List<CommandWithParties<CommandData>> commandWithPartiesList = transactionBuilder.toLedgerTransaction(getServiceHub()).getCommands();
for(CommandWithParties<CommandData> commandDataCommandWithParties : commandWithPartiesList) {
if(((ArrayList<PublicKey>)(getServiceHub().getKeyManagementService().filterMyKeys(commandDataCommandWithParties.getSigners()))).size() > 0) {
mySigners.add(((ArrayList<PublicKey>)getServiceHub().getKeyManagementService().filterMyKeys(commandDataCommandWithParties.getSigners())).get(0));
}
}
FlowSession rcvSession = initiateFlow(rcvAccountInfo.getHost());
SignedTransaction selfSignedTransaction = getServiceHub().signInitialTransaction(transactionBuilder, mySigners);
subFlow(new FinalityFlow(selfSignedTransaction, Arrays.asList(rcvSession)));
return null;
}
public TokenType getInstance(String currencyCode) {
Currency currency = Currency.getInstance(currencyCode);
return new TokenType(currency.getCurrencyCode(), 0);
}
}
#InitiatedBy(MoveTokensBetweenAccounts.class)
class MoveTokensBetweenAccountsResponder extends FlowLogic<Void> {
private final FlowSession otherSide;
public MoveTokensBetweenAccountsResponder(FlowSession otherSide) {
this.otherSide = otherSide;
}
#Override
#Suspendable
public Void call() throws FlowException {
subFlow(new ReceiveFinalityFlow(otherSide));
return null;
}
}
Am I missing anything fundamental while writing this MoveTokensBetweenAccounts Contract? I followed the official Github Samples
Any concrete suggestion to implement this Token-Movement would be of a great help!
Thank You!

Answer 1

QueryUtilities.heldTokenAmountCriteria() doesn't work with accounts; it only works with parties, instead you must use the following:
// Query vault for balance.
QueryCriteria heldByAccount = new QueryCriteria.VaultQueryCriteria().withExternalIds(Collections.singletonList(accountInfo.getIdentifier().getId()));
QueryCriteria queryCriteria = QueryUtilitiesKt
// Specify token type and issuer.
.tokenAmountWithIssuerCriteria(tokenTypePointer, issuer)
// Specify account.
.and(heldByAccount)
// Group by token type and aggregate.
.and(QueryUtilitiesKt.sumTokenCriteria());
Vault.Page<FungibleToken> results = proxy.vaultQueryByCriteria(queryCriteria, FungibleToken.class);
Amount<TokenType> totalBalance = QueryUtilitiesKt.rowsToAmount(tokenTypePointer, results);
Depending on the type of your token (fungible or non-fungible); I would use addMoveFungibleTokens() or addMoveNonFungibleTokens() instead of addMoveTokens().
Honestly I don't understand why you used the utility functions (i.e. DatabaseTokenSelection.generateMove() and addMoveTokens()); you use those if your transaction has multiple types of states as inputs/outputs (e.g. a car token and a US dollar token) and you want the swap of tokens to be atomic (either everything succeeds or everything fails). In your case, your transaction only has one type of states which is your token. You don't need all that complexity; just use the Tokens SDK out-of-the-box MoveFungibleTokensFlow.
Also, in your question you don't share how you found out that the tokens didn't move; did you create a flow test? How did that test query the accounts for their balance before and after the move?
Here's a simple example about moving tokens between 2 accounts; only thing that need to be changed in that example is to replace null here with a query criteria to only consume the tokens of the sender (see below); otherwise that move will consume any tokens that are held on the source node (you might end up moving tokens that belong to a different account; that's why you have to specify that query criteria):
// Query vault for balance.
QueryCriteria heldBySender = new QueryCriteria.VaultQueryCriteria().withExternalIds(Collections.singletonList(accountInfo.getIdentifier().getId()));
I highly recommend that you read my article on Tokens SDK, and even more important; go through the official free Corda course from R3; they have a big section on libraries (Tokens and Accounts), see here.
Also you have a typo, it's branch; not brunch.