add minter to NFT / 1155 tokens

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tatumio/tatum",
-  "version": "1.29.6",
+  "version": "1.29.7",
   "description": "Tatum API client allows browsers and Node.js clients to interact with Tatum API.",
   "main": "dist/src/index.js",
   "repository": "https://github.com/tatumio/tatum-js",

src/model/request/AddMinter.ts

@@ -0,0 +1,34 @@
+import {Type} from 'class-transformer';
+import {IsIn, IsNotEmpty, IsOptional, Length, Min, ValidateIf, ValidateNested} from 'class-validator';
+import {Currency} from './Currency';
+import {Fee} from './Fee';
+import {PrivateKeyOrSignatureId} from './PrivateKeyOrSignatureId';
+
+export class AddMinter extends PrivateKeyOrSignatureId {
+
+    @IsNotEmpty()
+    @Length(42, 43)
+    public minter: string;
+
+    @IsNotEmpty()
+    @Length(42, 43)
+    public contractAddress: string;
+
+    @IsNotEmpty()
+    @IsIn([Currency.BSC, Currency.ETH, Currency.CELO, Currency.ONE, Currency.MATIC])
+    public chain: Currency;
+
+    @Min(0)
+    @IsOptional()
+    public nonce?: number;
+
+    @IsOptional()
+    @Type(() => Fee)
+    @ValidateNested()
+    public fee?: Fee;
+
+    @ValidateIf(o => o.chain === Currency.CELO)
+    @IsNotEmpty()
+    @IsIn([Currency.CELO, Currency.CUSD, Currency.CEUR])
+    public feeCurrency?: Currency = Currency.CELO;
+}

src/model/request/index.ts

@@ -8,6 +8,7 @@ export * from './TransferXlmOffchainKMS';
 export * from './TransferXrpOffchainKMS';
 export * from './TransferBchBlockchain';
 export * from './GenerateCustodialAddressBatch';
+export * from './AddMinter';
 export * from './TransferBtcBasedBlockchain';
 export * from './TransferErc20';
 export * from './TransferFlowCustomTx';
@@ -146,4 +147,4 @@ export * from './UpdateCashbackErc721'
 export * from './PrivateKeyOrSignatureIdBtcBased'
 export {ContractType} from './ContractType'
 export * from './egld'
-export * from './AlgoTransaction'
+export * from './AlgoTransaction'

src/multiToken/index.ts

@@ -1,5 +1,9 @@
-import {get} from '../connector/tatum';
+import {get, validateBody} from '../connector/tatum';
+import abi from '../contracts/erc1155/erc1155_abi';
+import {helperBroadcastTx, helperPrepareSCCall} from '../helpers';
 import {
+    AddMinter,
+    BurnMultiToken,
     CeloBurnMultiToken,
     CeloBurnMultiTokenBatch,
     CeloDeployMultiToken,
@@ -14,12 +18,14 @@ import {
     MintMultiToken,
     MintMultiTokenBatch,
     TransferMultiToken,
-    TransferMultiTokenBatch,
-    BurnMultiToken
+    TransferMultiTokenBatch
 } from '../model';
 import {
     prepareOneBatchTransferMultiTokenSignedTransaction,
     preparePolygonBatchTransferMultiTokenSignedTransaction,
+    sendAlgoBurnFractionalNFTSignedTransaction,
+    sendAlgoCreateFractionalNFTSignedTransaction,
+    sendAlgoTransferFractionalNFTSignedTransaction,
     sendBscBurnBatchMultiTokenTransaction,
     sendBscBurnMultiTokenTransaction,
     sendBscDeployMultiTokenTransaction,
@@ -52,10 +58,7 @@ import {
     sendPolygonDeployMultiTokenSignedTransaction,
     sendPolygonMintMultiTokenBatchSignedTransaction,
     sendPolygonMintMultiTokenSignedTransaction,
-    sendPolygonTransferMultiTokenSignedTransaction,
-    sendAlgoCreateFractionalNFTSignedTransaction,
-    sendAlgoBurnFractionalNFTSignedTransaction,
-    sendAlgoTransferFractionalNFTSignedTransaction
+    sendPolygonTransferMultiTokenSignedTransaction
 } from '../transaction';
 
 /**
@@ -90,108 +93,176 @@ export const getMultiTokenMetadata = async (chain: Currency, contractAddress: st
     get(`/v3/multitoken/metadata/${chain}/${contractAddress}/${tokenId}`)
 
 
+/**
+ * Deploy MultiTokens (1155) contract.
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const deployMultiToken = async (testnet: boolean, body: CeloDeployMultiToken | EthDeployMultiToken, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
             return sendCeloDeployMultiTokenTransaction(testnet, body as CeloDeployMultiToken, provider)
         case Currency.MATIC:
-            return sendPolygonDeployMultiTokenSignedTransaction(testnet, body, provider)
+            return sendPolygonDeployMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return sendOneDeployMultiTokenSignedTransaction(testnet, body, provider)
+            return sendOneDeployMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.ETH:
-            return sendEthDeployMultiTokenTransaction(body, provider)
+            return sendEthDeployMultiTokenTransaction(body, provider);
         case Currency.BSC:
-            return sendBscDeployMultiTokenTransaction(body, provider)
+            return sendBscDeployMultiTokenTransaction(body, provider);
     }
 }
+
+/**
+ * Mint MultiTokens (1155)
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const mintMultiToken = async (testnet: boolean, body: MintMultiToken | CeloMintMultiToken, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
-            return sendCeloMintMultiTokenTransaction(testnet, body as CeloMintMultiToken, provider)
+            return sendCeloMintMultiTokenTransaction(testnet, body as CeloMintMultiToken, provider);
         case Currency.ETH:
-            return sendEthMintMultiTokenTransaction(body, provider)
+            return sendEthMintMultiTokenTransaction(body, provider);
         case Currency.MATIC:
-            return sendPolygonMintMultiTokenSignedTransaction(testnet, body, provider)
+            return sendPolygonMintMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return sendOneMintMultiTokenSignedTransaction(testnet, body, provider)
+            return sendOneMintMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.BSC:
-            return sendBscMintMultiTokenTransaction(body, provider)
+            return sendBscMintMultiTokenTransaction(body, provider);
         case Currency.ALGO:
-            return sendAlgoCreateFractionalNFTSignedTransaction(testnet, body as MintMultiToken, provider)
+            return sendAlgoCreateFractionalNFTSignedTransaction(testnet, body as MintMultiToken, provider);
     }
-}
+};
+
+/**
+ * Mint MultiTokens (1155) in a batch call.
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const mintMultiTokenBatch = async (testnet: boolean, body: MintMultiTokenBatch | CeloMintMultiTokenBatch, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
-            return sendCeloMintMultiTokenBatchTransaction(testnet, body as CeloMintMultiTokenBatch, provider)
+            return sendCeloMintMultiTokenBatchTransaction(testnet, body as CeloMintMultiTokenBatch, provider);
         case Currency.ETH:
-            return sendEthMintMultiTokenBatchTransaction(body, provider)
+            return sendEthMintMultiTokenBatchTransaction(body, provider);
         case Currency.MATIC:
-            return sendPolygonMintMultiTokenBatchSignedTransaction(testnet, body, provider)
+            return sendPolygonMintMultiTokenBatchSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return sendOneMintMultiTokenBatchSignedTransaction(testnet, body, provider)
+            return sendOneMintMultiTokenBatchSignedTransaction(testnet, body, provider);
         case Currency.BSC:
-            return sendBscMintMultiTokenBatchTransaction(body, provider)
+            return sendBscMintMultiTokenBatchTransaction(body, provider);
     }
-}
+};
+
+/**
+ * Burn MultiTokens (1155).
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const burnMultiToken = async (testnet: boolean, body: CeloBurnMultiToken | EthBurnMultiToken | BurnMultiToken, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
-            return sendCeloBurnMultiTokenTransaction(testnet, body as CeloBurnMultiToken, provider)
+            return sendCeloBurnMultiTokenTransaction(testnet, body as CeloBurnMultiToken, provider);
         case Currency.ETH:
-            return sendEthBurnMultiTokenTransaction(body, provider)
+            return sendEthBurnMultiTokenTransaction(body, provider);
         case Currency.MATIC:
-            return sendPolygonBurnMultiTokenSignedTransaction(testnet, body, provider)
+            return sendPolygonBurnMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return sendOneBurnMultiTokenSignedTransaction(testnet, body, provider)
+            return sendOneBurnMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.BSC:
-            return sendBscBurnMultiTokenTransaction(body, provider)
+            return sendBscBurnMultiTokenTransaction(body, provider);
         case Currency.ALGO:
-            return sendAlgoBurnFractionalNFTSignedTransaction(testnet, body as BurnMultiToken, provider)
+            return sendAlgoBurnFractionalNFTSignedTransaction(testnet, body as BurnMultiToken, provider);
     }
-}
+};
+
+/**
+ * Burn MultiTokens (1155) in a batch call.
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const burnMultiTokenBatch = async (testnet: boolean, body: CeloBurnMultiTokenBatch | EthBurnMultiTokenBatch, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
-            return sendCeloBurnMultiTokenBatchTransaction(testnet, body as CeloBurnMultiTokenBatch, provider)
+            return sendCeloBurnMultiTokenBatchTransaction(testnet, body as CeloBurnMultiTokenBatch, provider);
         case Currency.ETH:
-            return sendEthBurnBatchMultiTokenTransaction(body, provider)
+            return sendEthBurnBatchMultiTokenTransaction(body, provider);
         case Currency.MATIC:
-            return sendPolygonBurnMultiTokenBatchSignedTransaction(testnet, body, provider)
+            return sendPolygonBurnMultiTokenBatchSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return sendOneBurnMultiTokenBatchSignedTransaction(testnet, body, provider)
+            return sendOneBurnMultiTokenBatchSignedTransaction(testnet, body, provider);
         case Currency.BSC:
             return sendBscBurnBatchMultiTokenTransaction(body, provider)
     }
 }
 
+/**
+ * Transfer MultiTokens (1155).
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const transferMultiToken = async (testnet: boolean, body: CeloTransferMultiToken | TransferMultiToken, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
             return sendCeloTransferMultiTokenTransaction(testnet, body as CeloTransferMultiToken, provider)
         case Currency.ETH:
             return sendEthMultiTokenTransaction(body, provider)
         case Currency.MATIC:
-            return sendPolygonTransferMultiTokenSignedTransaction(testnet, body, provider)
+            return sendPolygonTransferMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return sendOneTransferMultiTokenSignedTransaction(testnet, body, provider)
+            return sendOneTransferMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.BSC:
-            return sendBscMultiTokenTransaction(body, provider)
+            return sendBscMultiTokenTransaction(body, provider);
         case Currency.ALGO:
-            return sendAlgoTransferFractionalNFTSignedTransaction(testnet, body as TransferMultiToken, provider)
+            return sendAlgoTransferFractionalNFTSignedTransaction(testnet, body as TransferMultiToken, provider);
     }
 }
+
+/**
+ * Transfer MultiTokens (1155) in a batch call.
+ * @param testnet if we use testnet or not
+ * @param body body of the request
+ * @param provider optional provider do broadcast tx
+ */
 export const transferMultiTokenBatch = async (testnet: boolean, body: CeloTransferMultiTokenBatch | TransferMultiTokenBatch, provider?: string) => {
     switch (body.chain) {
         case Currency.CELO:
-            return sendCeloTransferMultiTokenBatchTransaction(testnet, body as CeloTransferMultiTokenBatch, provider)
+            return sendCeloTransferMultiTokenBatchTransaction(testnet, body as CeloTransferMultiTokenBatch, provider);
         case Currency.ETH:
-            return sendEthMultiTokenBatchTransaction(body, provider)
+            return sendEthMultiTokenBatchTransaction(body, provider);
         case Currency.MATIC:
-            return preparePolygonBatchTransferMultiTokenSignedTransaction(testnet, body, provider)
+            return preparePolygonBatchTransferMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.ONE:
-            return prepareOneBatchTransferMultiTokenSignedTransaction(testnet, body, provider)
+            return prepareOneBatchTransferMultiTokenSignedTransaction(testnet, body, provider);
         case Currency.BSC:
-            return sendBscMultiTokenBatchTransaction(body, provider)
+            return sendBscMultiTokenBatchTransaction(body, provider);
     }
-}
+};
+
+/**
+ * Prepare add new minter to the MultiToken (1155) contract transaction.
+ * @param testnet if we use testnet or not
+ * @param body body of the add minter request
+ * @param provider optional provider do broadcast tx
+ */
+export const prepareAddMultiTokenMinter = async (testnet: boolean, body: AddMinter, provider?: string) => {
+    await validateBody(body, AddMinter);
+    const params = ['0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6', body.minter];
+    return await helperPrepareSCCall(testnet, body, AddMinter, 'grantRole', params, undefined, provider, abi);
+};
+
+/**
+ * Add new minter to the MultiToken (1155) contract.
+ * @param testnet if we use testnet or not
+ * @param body body of the add minter request
+ * @param provider optional provider do broadcast tx
+ */
+export const sendAddMultiTokenMinter = async (testnet: boolean, body: AddMinter, provider?: string) =>
+    helperBroadcastTx(body.chain, await prepareAddMultiTokenMinter(testnet, body, provider), body.signatureId);