Update to TokenSDK 1.2 Beta

Author: ashutoshmeher-r3

Tokens/dollartohousetoken/README.md

@@ -1,4 +1,4 @@
-# nonfungible house token dvp sample cordapp
+# Nonfungible house token dvp sample cordapp
 
 This CorDapp provides a basic example to create, issue and perform a DvP (Delivery vs Payment) of an Evolvable NonFungible token in 
 Corda utilizing the Token SDK.

Tokens/dollartohousetoken/build.gradle

@@ -15,15 +15,15 @@ buildscript {
 
         //Tokens
         tokens_release_group = 'com.r3.corda.lib.tokens'
-        tokens_release_version = '1.0'
+        tokens_release_version = '1.2-RC02-PRESIGN'
 
     }
 
     repositories {
         mavenLocal()
         mavenCentral()
         jcenter()
-        maven { url 'https://ci-artifactory.corda.r3cev.com/artifactory/corda' }
+        maven { url 'https://ci-artifactory.corda.r3cev.com/artifactory/corda-releases' }
     }
 
     dependencies {
@@ -105,7 +105,7 @@ dependencies {
     // Token SDK dependencies.
     cordapp "$tokens_release_group:tokens-contracts:$tokens_release_version"
     cordapp "$tokens_release_group:tokens-workflows:$tokens_release_version"
-    cordapp "$tokens_release_group:tokens-money:$tokens_release_version"
+   // cordapp "$tokens_release_group:tokens-money:$tokens_release_version"
 }
 
 task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
@@ -115,7 +115,7 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
         }
         cordapp("$tokens_release_group:tokens-contracts:$tokens_release_version")
         cordapp("$tokens_release_group:tokens-workflows:$tokens_release_version")
-        cordapp("$tokens_release_group:tokens-money:$tokens_release_version")
+        //cordapp("$tokens_release_group:tokens-money:$tokens_release_version")
         cordapp project(':contracts')
         cordapp project(':workflows')
     }

Tokens/dollartohousetoken/contracts/build.gradle

@@ -23,5 +23,5 @@ dependencies {
 
     // Token SDK dependencies.
     cordaCompile "$tokens_release_group:tokens-contracts:$tokens_release_version"
-    cordaCompile "$tokens_release_group:tokens-money:$tokens_release_version"
+  //  cordaCompile "$tokens_release_group:tokens-money:$tokens_release_version"
 }

Tokens/dollartohousetoken/workflows/build.gradle

@@ -51,7 +51,7 @@ dependencies {
     cordapp project(":contracts")
 
     // Token SDK dependencies.
-    cordaCompile "$tokens_release_group:tokens-money:$tokens_release_version"
+   // cordaCompile "$tokens_release_group:tokens-money:$tokens_release_version"
     cordaCompile "$tokens_release_group:tokens-workflows:$tokens_release_version"
 }
 

Tokens/dollartohousetoken/workflows/src/main/java/net/corda/examples/dollartohousetoken/flows/FiatCurrencyIssueFlow.java

@@ -6,14 +6,17 @@
 import com.r3.corda.lib.tokens.contracts.types.IssuedTokenType;
 import com.r3.corda.lib.tokens.contracts.types.TokenType;
 import com.r3.corda.lib.tokens.money.FiatCurrency;
+import com.r3.corda.lib.tokens.money.MoneyUtilities;
 import com.r3.corda.lib.tokens.workflows.flows.rpc.IssueTokens;
+import com.r3.corda.lib.tokens.workflows.utilities.FungibleTokenBuilder;
 import net.corda.core.contracts.Amount;
 import net.corda.core.flows.FlowException;
 import net.corda.core.flows.FlowLogic;
 import net.corda.core.flows.FlowSession;
 import net.corda.core.flows.StartableByRPC;
 import net.corda.core.identity.Party;
 import net.corda.core.transactions.SignedTransaction;
+import org.intellij.lang.annotations.Flow;
 
 /**
  * Flow class to issue fiat currency. FiatCurrency is defined in the Token SDK and is issued as a Fungible Token.
@@ -37,16 +40,35 @@ public FiatCurrencyIssueFlow(String currency, Long amount, Party recipient) {
     @Suspendable
     public SignedTransaction call() throws FlowException {
         /* Create an instance of the fiat currency token */
-        TokenType token = FiatCurrency.Companion.getInstance(currency);
-
-        /* Create an instance of IssuedTokenType for the fiat currency */
-        IssuedTokenType issuedTokenType = new IssuedTokenType(getOurIdentity(), token);
+        TokenType tokenType = getTokenType();
 
         /* Create an instance of FungibleToken for the fiat currency to be issued */
-        FungibleToken fungibleToken = new FungibleToken(new Amount<>(amount, issuedTokenType), recipient, null);
+        FungibleToken fungibleToken =
+                new FungibleTokenBuilder()
+                    .ofTokenType(tokenType)
+                    .withAmount(amount)
+                    .issuedBy(getOurIdentity())
+                    .heldBy(recipient)
+                    .buildFungibleToken();
 
         /* Issue the required amount of the token to the recipient */
         return subFlow(new IssueTokens(ImmutableList.of(fungibleToken), ImmutableList.of(recipient)));
     }
 
+    private TokenType getTokenType() throws FlowException{
+        switch (currency){
+            case "USD":
+                return MoneyUtilities.getUSD();
+
+            case "GBP":
+                return MoneyUtilities.getGBP();
+
+            case "EUR":
+                return MoneyUtilities.getEUR();
+
+            default:
+                throw new FlowException("Currency Not Supported");
+        }
+    }
+
 }

Tokens/dollartohousetoken/workflows/src/main/java/net/corda/examples/dollartohousetoken/flows/HouseSaleInitiatorFlow.java

@@ -1,10 +1,10 @@
 package net.corda.examples.dollartohousetoken.flows;
 
 import co.paralleluniverse.fibers.Suspendable;
+import com.r3.corda.lib.tokens.workflows.flows.move.MoveTokensUtilities;
 import net.corda.examples.dollartohousetoken.states.HouseState;
 import com.google.common.collect.ImmutableList;
 import com.r3.corda.lib.tokens.contracts.states.FungibleToken;
-import com.r3.corda.lib.tokens.workflows.flows.move.MoveTokensUtilitiesKt;
 import com.r3.corda.lib.tokens.workflows.internal.flows.distribution.UpdateDistributionListFlow;
 import net.corda.core.contracts.StateAndRef;
 import net.corda.core.flows.*;
@@ -58,7 +58,7 @@ public String call() throws FlowException {
 
         /* Create a move token proposal for the house token using the helper function provided by Token SDK. This would
         create the movement proposal and would be committed in the ledgers of parties once the transaction in finalized */
-        MoveTokensUtilitiesKt.addMoveNonFungibleTokens(txBuilder, getServiceHub(), houseState.toPointer(), buyer);
+        MoveTokensUtilities.addMoveNonFungibleTokens(txBuilder, getServiceHub(), houseState.toPointer(), buyer);
 
         /* Initiate a flow session with the buyer to send the house valuation and transfer of the fiat currency */
         FlowSession buyerSession = initiateFlow(buyer);
@@ -73,7 +73,7 @@ public String call() throws FlowException {
         List<FungibleToken> moneyReceived = buyerSession.receive(List.class).unwrap(value -> value);
 
         /* Create a fiat currency proposal for the house token using the helper function provided by Token SDK */
-        MoveTokensUtilitiesKt.addMoveTokens(txBuilder, inputs, moneyReceived);
+        MoveTokensUtilities.addMoveTokens(txBuilder, inputs, moneyReceived);
 
         /* Sign the transaction */
         SignedTransaction initialSignedTrnx = getServiceHub().signInitialTransaction(txBuilder, getOurIdentity().getOwningKey());

Tokens/dollartohousetoken/workflows/src/main/java/net/corda/examples/dollartohousetoken/flows/HouseSaleResponderFlow.java

@@ -5,7 +5,7 @@
 import com.r3.corda.lib.tokens.contracts.states.FungibleToken;
 import com.r3.corda.lib.tokens.contracts.types.TokenType;
 import com.r3.corda.lib.tokens.money.FiatCurrency;
-import com.r3.corda.lib.tokens.workflows.internal.selection.TokenSelection;
+import com.r3.corda.lib.tokens.selection.database.selector.DatabaseTokenSelection;
 import com.r3.corda.lib.tokens.workflows.types.PartyAndAmount;
 import kotlin.Pair;
 import net.corda.core.contracts.Amount;
@@ -14,6 +14,7 @@
 import net.corda.core.transactions.SignedTransaction;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Collections;
 import java.util.Currency;
 import java.util.List;
 
@@ -40,17 +41,13 @@ public SignedTransaction call() throws FlowException {
         /* Create instance of the fiat currency token amount */
         Amount<TokenType> priceToken = new Amount<>(price.getQuantity(), FiatCurrency.Companion.getInstance(price.getToken().getCurrencyCode()));
 
-        /* Create an instance of the TokenSelection object, it is used to select the token from the vault and generate the
-        proposal for the movement of the token. The constructor takes the service hub to perform vault query, the max-number
-        of retries, the retry sleep interval, and the retry sleep cap interval. This is a temporary solution till in-memory
-        token selection in implemented */
-        TokenSelection tokenSelection = new TokenSelection(getServiceHub(), 8, 100, 2000);
 
         /* Generate the move proposal, it returns the input-output pair for the fiat currency transfer, which we need to
         send to the Initiator */
         PartyAndAmount<TokenType> partyAndAmount = new PartyAndAmount<>(counterpartySession.getCounterparty(), priceToken);
-        Pair<List<StateAndRef<FungibleToken>>, List<FungibleToken>> inputsAndOutputs =
-                tokenSelection.generateMove(getRunId().getUuid(), ImmutableList.of(partyAndAmount), getOurIdentity(), null);
+        Pair<List<StateAndRef<FungibleToken>>, List<FungibleToken>> inputsAndOutputs = new DatabaseTokenSelection(getServiceHub())
+                // here we are generating input and output states which send the correct amount to the seller, and any change back to buyer
+                .generateMove(Collections.singletonList(new Pair<>(counterpartySession.getCounterparty(), priceToken)), getOurIdentity());
 
         /* Call SendStateAndRefFlow to send the inputs to the Initiator */
         subFlow(new SendStateAndRefFlow(counterpartySession, inputsAndOutputs.getFirst()));

Tokens/dollartohousetoken/workflows/src/main/java/net/corda/examples/dollartohousetoken/flows/HouseTokenCreateAndIssueFlow.java

@@ -1,6 +1,7 @@
 package net.corda.examples.dollartohousetoken.flows;
 
 import co.paralleluniverse.fibers.Suspendable;
+import com.r3.corda.lib.tokens.workflows.utilities.NonFungibleTokenBuilder;
 import net.corda.examples.dollartohousetoken.states.HouseState;
 import com.google.common.collect.ImmutableList;
 import com.r3.corda.lib.tokens.contracts.states.NonFungibleToken;
@@ -66,16 +67,15 @@ public String call() throws FlowException {
         evolvable token in the ledger.*/
         subFlow(new CreateEvolvableTokens(transactionState));
 
-        /* Create an instance of IssuedTokenType, it is used by our Non-Fungible token which would be issued to the owner.
-        Note that the IssuedTokenType takes a TokenPointer as an input, since EvolvableTokenType is not TokenType, but is
-        a LinearState. This is done to separate the state info from the token so that the state can evolve independently.
-        IssuedTokenType is a wrapper around the TokenType and the issuer. */
-        IssuedTokenType issuedHouseToken = new IssuedTokenType(issuer, houseState.toPointer());
-
-        /* Create an instance of the non-fungible house token with the owner as the token holder. The last parameter is a
-        hash of the jar containing the TokenType, use the helper function to fetch it. */
-        NonFungibleToken houseToken =
-                new NonFungibleToken(issuedHouseToken, owner, UniqueIdentifier.Companion.fromString(UUID.randomUUID().toString()), TransactionUtilitiesKt.getAttachmentIdForGenericParam(houseState.toPointer()));
+        /* Create an instance of the non-fungible house token with the owner as the token holder.
+        * Notice the TokenPointer is used as the TokenType, since EvolvableTokenType is not TokenType, but is
+        * a LinearState. This is done to separate the state info from the token so that the state can evolve independently.
+        * */
+        NonFungibleToken houseToken = new NonFungibleTokenBuilder()
+                .ofTokenType(houseState.toPointer())
+                .issuedBy(issuer)
+                .heldBy(owner)
+                .buildNonFungibleToken();
 
         /* Issue the house token by calling the IssueTokens flow provided with the TokenSDK */
         SignedTransaction stx = subFlow(new IssueTokens(ImmutableList.of(houseToken)));