Smart contract schema support

CHANGELOG.md

@@ -1,6 +1,8 @@
 # Changelog
 
 ## Unreleased changes
+- Implemented custom serialization of `AbstractAddress` and added class `ListParam` for conveniently using lists of objects, `AbstractAddress`, `ContractAddress` and `AccountAddress` as smart contract parameters.
+- Added support for creating and serializing smart contract parameters using the abstract class `SchemaParameter` and a provided `Schema`.
 
 ## 5.1.0
 - Fixed a regression that made it harder to deserialize transactions from bytes.

concordium-sdk-examples/src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/Cis2Nft.java

@@ -0,0 +1,162 @@
+package com.concordium.sdk.examples.contractexample.cis2nft;
+
+import com.concordium.sdk.ClientV2;
+import com.concordium.sdk.Connection;
+import com.concordium.sdk.crypto.ed25519.ED25519SecretKey;
+import com.concordium.sdk.exceptions.ClientInitializationException;
+import com.concordium.sdk.requests.AccountQuery;
+import com.concordium.sdk.requests.BlockQuery;
+import com.concordium.sdk.responses.modulelist.ModuleRef;
+import com.concordium.sdk.transactions.*;
+import com.concordium.sdk.transactions.smartcontracts.SchemaParameter;
+import com.concordium.sdk.types.AccountAddress;
+import com.concordium.sdk.types.ContractAddress;
+import com.concordium.sdk.types.Nonce;
+import com.concordium.sdk.types.UInt64;
+import lombok.SneakyThrows;
+import lombok.var;
+import picocli.CommandLine;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.concurrent.Callable;
+
+/**
+ * Calls different methods on a <a href="https://github.com/Concordium/concordium-rust-smart-contracts/blob/main/examples/cis2-nft/src/lib.rs">cis2-nft smart contract</a> deployed on the chain.
+ * See {@link Cis2NftParameters} for how to create and initialize custom smart contract parameters.
+ * SENDER_ADDRESS, MODULE_REF, CONTRACT_ADDRESS and the key in SIGNER are dummy values and should be replaced
+ */
+@CommandLine.Command(name = "Cis2Nft", mixinStandardHelpOptions = true)
+public class Cis2Nft implements Callable<Integer> {
+
+    private static final String SENDER_ADDRESS = "3WZE6etUvVp1eyhEtTxqZrQaanTAZnZCHEmZmDyCbCwxnmQuPE"; //  Dummy address
+    private static final ModuleRef MODULE_REF = ModuleRef.from("247a7ac6efd2e46f72fd18741a6d1a0254ec14f95639df37079a576b2033873e"); // Dummy module ref
+    private static final ContractAddress CONTRACT_ADDRESS = ContractAddress.from(1, 0); // Dummy contract address
+
+    private static final Expiry EXPIRY = Expiry.createNew().addMinutes(5);
+
+    private static final TransactionSigner SIGNER = TransactionSigner.from(
+            SignerEntry.from(Index.from(0), Index.from(0), // TODO dummy key
+                    ED25519SecretKey.from("56f60de843790c308dac2d59a5eec9f6b1649513f827e5a13d7038accfe31784")) // Dummy key
+    );
+
+    @CommandLine.Option(
+            names = {"-m", "--method"},
+            required = true,
+            description = "Name of method. Valid names are: ${COMPLETION-CANDIDATES}")
+    private Cis2NftMethod methodName;
+
+    @CommandLine.Option(
+            names = {"--endpoint"},
+            description = "GRPC interface of the node.",
+            defaultValue = "http://localhost:20002")
+    private String endpoint;
+
+    @CommandLine.Option(
+            names = {"--timeout"},
+            description = "GRPC request timeout in milliseconds.",
+            defaultValue = "100000")
+    private int timeout;
+
+
+    @Override
+    public Integer call() throws IOException, ClientInitializationException {
+        var endpointUrl = new URL(this.endpoint);
+        Connection connection = Connection.newBuilder()
+                .host(endpointUrl.getHost())
+                .port(endpointUrl.getPort())
+                .timeout(timeout)
+                .build();
+        var client = ClientV2.from(connection);
+        Nonce nonce = client.getAccountInfo(BlockQuery.BEST, AccountQuery.from(AccountAddress.from(SENDER_ADDRESS))).getAccountNonce();
+
+        switch (this.methodName) {
+            case INIT:
+                handleInit(client, nonce);
+                break;
+            case MINT:
+                SchemaParameter mintParams = Cis2NftParameters.generateMintParams();
+                handleMethod(client, nonce, mintParams);
+                break;
+            case TRANSFER:
+                SchemaParameter transferParams = Cis2NftParameters.generateTransferParams();
+                handleMethod(client, nonce, transferParams);
+                break;
+            case UPDATE_OPERATOR:
+                SchemaParameter updateOperatorParams = Cis2NftParameters.generateUpdateOperatorParams();
+                handleMethod(client, nonce, updateOperatorParams);
+                break;
+            case OPERATOR_OF:
+                SchemaParameter operatorOfParams = Cis2NftParameters.generateOperatorOfParams();
+                handleMethod(client, nonce, operatorOfParams);
+                break;
+            case BALANCE_OF:
+                SchemaParameter balanceOfParams = Cis2NftParameters.generateBalanceOfParams();
+                handleMethod(client, nonce, balanceOfParams);
+                break;
+            case TOKEN_METADATA:
+                SchemaParameter tokenMetadataParams = Cis2NftParameters.generateTokenMetadataParams();
+                handleMethod(client, nonce, tokenMetadataParams);
+                break;
+            case SUPPORTS:
+                SchemaParameter supportsParams = Cis2NftParameters.generateSupportsParameter();
+                handleMethod(client, nonce, supportsParams);
+                break;
+            case SET_IMPLEMENTORS:
+                SchemaParameter setImplementorsParams = Cis2NftParameters.generateSetImplementorsParams();
+                handleMethod(client, nonce, setImplementorsParams);
+                break;
+        }
+        return 0;
+    }
+
+    private void handleInit(ClientV2 client, Nonce nonce) {
+        InitName initName = InitName.from("init_cis2_nft");
+        InitContractPayload payload = InitContractPayload.from(CCDAmount.fromMicro(0), MODULE_REF, initName, Parameter.EMPTY);
+        InitContractTransaction initContractTransaction = TransactionFactory.newInitContract()
+                .sender(AccountAddress.from(SENDER_ADDRESS))
+                .payload(payload)
+                .expiry(EXPIRY)
+                .nonce(AccountNonce.from(nonce))
+                .signer(SIGNER)
+                .maxEnergyCost(UInt64.from(10000))
+                .build();
+        Hash txHash = client.sendTransaction(initContractTransaction);
+        System.out.println("Submitted transaction for " + this.methodName  + " with hash: " + txHash);
+        sleep();
+        Hash blockHash = client.getBlockItemStatus(txHash).getFinalizedBlockItem().get().getBlockHash();
+        System.out.println("Transaction finalized in block with hash: " + blockHash);
+    }
+
+    private void handleMethod(ClientV2 client, Nonce nonce, SchemaParameter parameter) {
+        UpdateContract payload = UpdateContract.from(CONTRACT_ADDRESS, parameter);
+        UpdateContractTransaction transaction = TransactionFactory.newUpdateContract()
+                .sender(AccountAddress.from(SENDER_ADDRESS))
+                .payload(payload)
+                .expiry(EXPIRY)
+                .nonce(AccountNonce.from(nonce))
+                .signer(SIGNER)
+                .maxEnergyCost(UInt64.from(10000))
+                .build();
+        Hash txHash = client.sendTransaction(transaction);
+        System.out.println("Submitted transaction for " + this.methodName  + " with hash: " + txHash);
+        sleep();
+        Hash blockHash = client.getBlockItemStatus(txHash).getFinalizedBlockItem().get().getBlockHash();
+        System.out.println("Transaction finalized in block with hash: " + blockHash);
+    }
+
+    @SneakyThrows
+    private void sleep() {
+        for (int i = 0; i < 200; i++) {
+            System.out.print(".");
+            if (i % 50 == 0) {
+                System.out.println("\n");
+            }
+            Thread.sleep(30);
+        }
+    }
+    public static void main(String[] args) {
+        int exitCode = new CommandLine(new Cis2Nft()).execute(args);
+        System.exit(exitCode);
+    }
+}

concordium-sdk-examples/src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/Cis2NftMethod.java

@@ -0,0 +1,16 @@
+package com.concordium.sdk.examples.contractexample.cis2nft;
+
+/**
+ * Represents the different possible methods able to be run by {@link Cis2Nft}
+ */
+public enum Cis2NftMethod {
+    INIT,
+    MINT,
+    TRANSFER,
+    UPDATE_OPERATOR,
+    OPERATOR_OF,
+    BALANCE_OF,
+    TOKEN_METADATA,
+    SUPPORTS,
+    SET_IMPLEMENTORS,
+}

concordium-sdk-examples/src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/Cis2NftParameters.java

@@ -0,0 +1,140 @@
+package com.concordium.sdk.examples.contractexample.cis2nft;
+
+import com.concordium.sdk.examples.contractexample.parameters.*;
+import com.concordium.sdk.transactions.ReceiveName;
+import com.concordium.sdk.transactions.smartcontracts.Schema;
+import com.concordium.sdk.transactions.smartcontracts.SchemaParameter;
+import com.concordium.sdk.transactions.smartcontracts.SchemaVersion;
+import com.concordium.sdk.types.*;
+import lombok.SneakyThrows;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Helper class for creating and initializing parameters being used in {@link Cis2Nft}.
+ */
+public class Cis2NftParameters {
+
+    private static final AccountAddress ACCOUNT_ADDRESS = AccountAddress.from("3XSLuJcXg6xEua6iBPnWacc3iWh93yEDMCqX8FbE3RDSbEnT9P");
+    private static  final ContractAddress CONTRACT_ADDRESS_1 = ContractAddress.from(1, 0);
+    private static final ContractAddress CONTRACT_ADDRESS_2 = ContractAddress.from(2, 0);
+
+    private static final String CIS_2_NFT_CONTRACT_NAME = "cis2_nft";
+
+    @SneakyThrows
+    public static SchemaParameter generateMintParams() {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName mintParamsReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "mint");
+        List<TokenIdU32> tokens = new ArrayList<>();
+        tokens.add(TokenIdU32.from(2));
+        tokens.add(TokenIdU32.from(22));
+        tokens.add(TokenIdU32.from(2132));
+        SchemaParameter mintParameter = new MintParams(schema, mintParamsReceiveName, ACCOUNT_ADDRESS, tokens);
+        mintParameter.initialize(true);
+        return mintParameter;
+    }
+
+    @SneakyThrows
+    public static SchemaParameter generateTransferParams() {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName nftTransferReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "transfer");
+        TokenIdU32 tokenId = TokenIdU32.from(12);
+        TokenAmountU8 amount = TokenAmountU8.from(1);
+        AbstractAddress from = CONTRACT_ADDRESS_1;
+        Receiver to = new Receiver(CONTRACT_ADDRESS_2, "mint");
+        List<UInt8> data = new ArrayList<>();
+        data.add(UInt8.from(123));
+        data.add(UInt8.from(23));
+        NftTransfer transfer = new NftTransfer(tokenId, amount, from, to, data);
+        List<NftTransfer> transfers = new ArrayList<>();
+        transfers.add(transfer);
+        SchemaParameter transferParameter = new NftTransferParam(schema, nftTransferReceiveName, transfers);
+        transferParameter.initialize(true);
+
+        return transferParameter;
+    }
+
+    @SneakyThrows
+    public static SchemaParameter generateUpdateOperatorParams() {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName updateOperatorReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "updateOperator");
+        UpdateOperator update1 = new UpdateOperator(UpdateOperator.OperatorUpdate.ADD, ACCOUNT_ADDRESS);
+        UpdateOperator update2 = new UpdateOperator(UpdateOperator.OperatorUpdate.REMOVE, CONTRACT_ADDRESS_1);
+        List<UpdateOperator> updateOperatorList = new ArrayList<>();
+        updateOperatorList.add(update1);
+        updateOperatorList.add(update2);
+        SchemaParameter updateOperatorsParams = new UpdateOperatorParams(schema, updateOperatorReceiveName, updateOperatorList);
+        updateOperatorsParams.initialize(true);
+
+        return updateOperatorsParams;
+    }
+
+    public static SchemaParameter generateOperatorOfParams() throws IOException {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName operatorOfReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "operatorOf");
+        OperatorOfQuery operatorOfQuery1 = new OperatorOfQuery(ACCOUNT_ADDRESS, CONTRACT_ADDRESS_1);
+        OperatorOfQuery operatorOfQuery2 = new OperatorOfQuery(CONTRACT_ADDRESS_1, CONTRACT_ADDRESS_2);
+        List<OperatorOfQuery> operatorOfQueries = new ArrayList<>();
+        operatorOfQueries.add(operatorOfQuery1);
+        operatorOfQueries.add(operatorOfQuery2);
+        SchemaParameter operatorOfQueryParams = new OperatorOfQueryParams(schema, operatorOfReceiveName, operatorOfQueries);
+        operatorOfQueryParams.initialize(true);
+        return operatorOfQueryParams;
+    }
+
+    public static SchemaParameter generateBalanceOfParams() throws IOException {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName balanceOfReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "balanceOf");
+        NftBalanceOfQuery balanceOfQuery1 = new NftBalanceOfQuery(TokenIdU32.from(22222), ACCOUNT_ADDRESS);
+        NftBalanceOfQuery balanceOfQuery2 = new NftBalanceOfQuery(TokenIdU32.from(42), CONTRACT_ADDRESS_1);
+        List<NftBalanceOfQuery> balanceOfQueries = new ArrayList<>();
+        balanceOfQueries.add(balanceOfQuery1);
+        balanceOfQueries.add(balanceOfQuery2);
+        SchemaParameter contractBalanceOfQueryParams = new NftBalanceOfQueryParams(schema, balanceOfReceiveName, balanceOfQueries);
+        contractBalanceOfQueryParams.initialize(true);
+        return contractBalanceOfQueryParams;
+    }
+
+    public static SchemaParameter generateTokenMetadataParams() throws IOException {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName tokenMetadataReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "tokenMetadata");
+        TokenIdU32 token1 = TokenIdU32.from(21);
+        TokenIdU32 token2 = TokenIdU32.from(22);
+        List<TokenIdU32> tokensForMetadataQuery = new ArrayList<>();
+        tokensForMetadataQuery.add(token1);
+        tokensForMetadataQuery.add(token2);
+        SchemaParameter nftMetaDataQuery = new NftMetaDataQuery(schema, tokenMetadataReceiveName, tokensForMetadataQuery);
+        nftMetaDataQuery.initialize(true);
+        return nftMetaDataQuery;
+    }
+
+    public static SchemaParameter generateSupportsParameter() throws IOException {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName supportsReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "supports");
+        String standardIdentifier1 = "identifier1";
+        String standardIdentifier2 = "identifier2";
+        List<String> identifiers = new ArrayList<>();
+        identifiers.add(standardIdentifier1);
+        identifiers.add(standardIdentifier2);
+        SchemaParameter supportsQueryParams = new SupportsQueryParams(schema, supportsReceiveName, identifiers);
+        supportsQueryParams.initialize(true);
+        return supportsQueryParams;
+    }
+
+    public static SchemaParameter generateSetImplementorsParams() throws IOException {
+        Schema schema = Schema.from(Files.readAllBytes(Paths.get("./src/main/java/com/concordium/sdk/examples/contractexample/cis2nft/cis2-nft.schema.bin")), SchemaVersion.V3);
+        ReceiveName setImplementorsReceiveName = ReceiveName.from(CIS_2_NFT_CONTRACT_NAME, "setImplementors");
+        List<ContractAddress> implementors = new ArrayList<>();
+        String identifier = "IdentifierID";
+        implementors.add(CONTRACT_ADDRESS_1);
+        implementors.add(CONTRACT_ADDRESS_2);
+        SchemaParameter setImplementorsParams = new SetImplementorsParams(schema, setImplementorsReceiveName, identifier, implementors);
+        setImplementorsParams.initialize();
+        return setImplementorsParams;
+    }
+
+}

concordium-sdk-examples/src/main/java/com/concordium/sdk/examples/contractexample/parameters/BalanceOfQuery.java

@@ -0,0 +1,19 @@
+package com.concordium.sdk.examples.contractexample.parameters;
+
+import com.concordium.sdk.types.AbstractAddress;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * Represents a '<a href = "https://github.com/Concordium/concordium-rust-smart-contracts/blob/main/concordium-cis2/src/lib.rs#L1138">BalanceOfQuery</a>' used in different smart contracts
+ */
+@Getter
+@AllArgsConstructor
+public class BalanceOfQuery<T extends TokenId> {
+    @JsonProperty("token_id")
+    private T tokenId;
+    @JsonSerialize(using = AbstractAddress.AbstractAddressJsonSerializer.class)
+    private AbstractAddress address;
+}

concordium-sdk-examples/src/main/java/com/concordium/sdk/examples/contractexample/parameters/MintParams.java

@@ -0,0 +1,34 @@
+package com.concordium.sdk.examples.contractexample.parameters;
+
+import com.concordium.sdk.transactions.ReceiveName;
+import com.concordium.sdk.transactions.smartcontracts.Schema;
+import com.concordium.sdk.transactions.smartcontracts.SchemaParameter;
+import com.concordium.sdk.types.AbstractAddress;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import lombok.Getter;
+
+import java.util.List;
+
+/**
+ * Represents the parameter 'MintParams' in the <a href="https://github.com/Concordium/concordium-rust-smart-contracts/blob/main/examples/cis2-nft/src/lib.rs#L49">cis2-nft example</a>
+ * Used with contract function 'mint' which mints a number of tokens to a given {@link AbstractAddress}.
+ */
+@Getter
+public class MintParams extends SchemaParameter {
+
+    /**
+     * Owner of the newly minted tokens.
+     */
+    @JsonSerialize(using = AbstractAddress.AbstractAddressJsonSerializer.class)
+    private final AbstractAddress owner;
+    /**
+     * A collection of tokens to mint.
+     */
+    private final List<TokenIdU32> tokens;
+
+    public MintParams(Schema schema, ReceiveName receiveName, AbstractAddress owner, List<TokenIdU32> tokens) {
+        super(schema, receiveName);
+        this.owner = owner;
+        this.tokens = tokens;
+    }
+}

concordium-sdk-examples/src/main/java/com/concordium/sdk/examples/contractexample/parameters/NftBalanceOfQuery.java

@@ -0,0 +1,13 @@
+package com.concordium.sdk.examples.contractexample.parameters;
+
+import com.concordium.sdk.types.AbstractAddress;
+
+/**
+ * Wrapper class for {@link BalanceOfQuery} enforcing the correct Token id for cis2-nft contract.
+ */
+public class NftBalanceOfQuery extends BalanceOfQuery<TokenIdU32> {
+
+    public NftBalanceOfQuery(TokenIdU32 tokenId, AbstractAddress address) {
+        super(tokenId, address);
+    }
+}