feat(sdk-coin-apt): send many support fungible asset

TICKET: COIN-3558

- Send Many for Multiple Recipients for Fungible Asset (Token)
- Refactoring to optimize code e.g.
-- moving buildRawTransaction to parent transaction and instead implementing specific getTransactionPayloadData
-- utils migration for parseRecipients

Author: baltiyal

modules/sdk-coin-apt/src/lib/constants.ts

@@ -11,6 +11,7 @@ export const AMOUNT_BYTES_LENGTH = 8;
 export const DIGITAL_ASSET_TRANSFER_AMOUNT = '1';
 
 export const FUNGIBLE_ASSET_TRANSFER_FUNCTION = '0x1::primary_fungible_store::transfer';
+export const FUNGIBLE_ASSET_BATCH_TRANSFER_FUNCTION = '0x1::aptos_account::batch_transfer_fungible_assets';
 export const COIN_TRANSFER_FUNCTION = '0x1::aptos_account::transfer_coins';
 export const COIN_BATCH_TRANSFER_FUNCTION = '0x1::aptos_account::batch_transfer_coins';
 export const DIGITAL_ASSET_TRANSFER_FUNCTION = '0x1::object::transfer';

modules/sdk-coin-apt/src/lib/transaction/digitalAssetTransfer.ts

@@ -1,11 +1,9 @@
 import { Transaction } from './transaction';
 import {
   AccountAddress,
-  Aptos,
-  AptosConfig,
   EntryFunctionABI,
+  InputGenerateTransactionPayloadData,
   MoveAbility,
-  Network,
   objectStructTag,
   TransactionPayload,
   TransactionPayloadEntryFunction,
@@ -14,7 +12,7 @@ import {
   TypeTagStruct,
 } from '@aptos-labs/ts-sdk';
 import { InvalidTransactionError, TransactionRecipient, TransactionType } from '@bitgo/sdk-core';
-import { BaseCoin as CoinConfig, NetworkType } from '@bitgo/statics';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import {
   DIGITAL_ASSET_TYPE_ARGUMENT,
   DIGITAL_ASSET_TRANSFER_FUNCTION,
@@ -46,33 +44,19 @@ export class DigitalAssetTransfer extends Transaction {
     ] as TransactionRecipient[];
   }
 
-  protected async buildRawTransaction(): Promise<void> {
-    const network: Network = this._coinConfig.network.type === NetworkType.MAINNET ? Network.MAINNET : Network.TESTNET;
-    const aptos = new Aptos(new AptosConfig({ network }));
-    const senderAddress = AccountAddress.fromString(this._sender);
+  protected getTransactionPayloadData(): InputGenerateTransactionPayloadData {
     const recipientAddress = AccountAddress.fromString(this.recipients[0].address);
     const digitalAssetAddress = AccountAddress.fromString(this._assetId);
-
     const transferDigitalAssetAbi: EntryFunctionABI = {
       typeParameters: [{ constraints: [MoveAbility.KEY] }],
       parameters: [new TypeTagStruct(objectStructTag(new TypeTagGeneric(0))), new TypeTagAddress()],
     };
 
-    const simpleTxn = await aptos.transaction.build.simple({
-      sender: senderAddress,
-      data: {
-        function: DIGITAL_ASSET_TRANSFER_FUNCTION,
-        typeArguments: [DIGITAL_ASSET_TYPE_ARGUMENT],
-        functionArguments: [digitalAssetAddress, recipientAddress],
-        abi: transferDigitalAssetAbi,
-      },
-      options: {
-        maxGasAmount: this.maxGasAmount,
-        gasUnitPrice: this.gasUnitPrice,
-        expireTimestamp: this.expirationTime,
-        accountSequenceNumber: this.sequenceNumber,
-      },
-    });
-    this._rawTransaction = simpleTxn.rawTransaction;
+    return {
+      function: DIGITAL_ASSET_TRANSFER_FUNCTION,
+      typeArguments: [DIGITAL_ASSET_TYPE_ARGUMENT],
+      functionArguments: [digitalAssetAddress, recipientAddress],
+      abi: transferDigitalAssetAbi,
+    };
   }
 }

modules/sdk-coin-apt/src/lib/transaction/fungibleAssetTransfer.ts

@@ -1,19 +1,21 @@
 import { Transaction } from './transaction';
 import {
   AccountAddress,
-  Aptos,
-  AptosConfig,
   EntryFunctionABI,
-  Network,
+  InputGenerateTransactionPayloadData,
   parseTypeTag,
   TransactionPayload,
   TransactionPayloadEntryFunction,
   TypeTagAddress,
   TypeTagU64,
 } from '@aptos-labs/ts-sdk';
-import { InvalidTransactionError, TransactionRecipient, TransactionType } from '@bitgo/sdk-core';
-import { BaseCoin as CoinConfig, NetworkType } from '@bitgo/statics';
-import { FUNGIBLE_ASSET_TYPE_ARGUMENT, FUNGIBLE_ASSET_TRANSFER_FUNCTION } from '../constants';
+import { InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import {
+  FUNGIBLE_ASSET_TYPE_ARGUMENT,
+  FUNGIBLE_ASSET_TRANSFER_FUNCTION,
+  FUNGIBLE_ASSET_BATCH_TRANSFER_FUNCTION,
+} from '../constants';
 import utils from '../utils';
 
 export class FungibleAssetTransfer extends Transaction {
@@ -23,50 +25,53 @@ export class FungibleAssetTransfer extends Transaction {
   }
 
   protected parseTransactionPayload(payload: TransactionPayload): void {
-    if (
-      !(payload instanceof TransactionPayloadEntryFunction) ||
-      payload.entryFunction.args.length !== 3 ||
-      payload.entryFunction.type_args.length !== 1 ||
-      FUNGIBLE_ASSET_TYPE_ARGUMENT !== payload.entryFunction.type_args[0].toString()
-    ) {
+    if (!this.isValidPayload(payload)) {
       throw new InvalidTransactionError('Invalid transaction payload');
     }
-    const entryFunction = payload.entryFunction;
+    const entryFunction = (payload as TransactionPayloadEntryFunction).entryFunction;
     this._assetId = entryFunction.args[0].toString();
-    this.recipients = [
-      {
-        address: entryFunction.args[1].toString(),
-        amount: utils.getAmountFromPayloadArgs(entryFunction.args[2].bcsToBytes()),
-      },
-    ] as TransactionRecipient[];
+    const addressArg = entryFunction.args[1];
+    const amountArg = entryFunction.args[2];
+    this.recipients = utils.parseRecipients(addressArg, amountArg);
   }
 
-  protected async buildRawTransaction(): Promise<void> {
-    const network: Network = this._coinConfig.network.type === NetworkType.MAINNET ? Network.MAINNET : Network.TESTNET;
-    const aptos = new Aptos(new AptosConfig({ network }));
-    const senderAddress = AccountAddress.fromString(this._sender);
-    const recipientAddress = AccountAddress.fromString(this.recipients[0].address);
+  protected getTransactionPayloadData(): InputGenerateTransactionPayloadData {
     const fungibleTokenAddress = this._assetId;
     const faTransferAbi: EntryFunctionABI = {
       typeParameters: [{ constraints: [] }],
       parameters: [parseTypeTag('0x1::object::Object'), new TypeTagAddress(), new TypeTagU64()],
     };
 
-    const simpleTxn = await aptos.transaction.build.simple({
-      sender: senderAddress,
-      data: {
-        function: FUNGIBLE_ASSET_TRANSFER_FUNCTION,
-        typeArguments: [FUNGIBLE_ASSET_TYPE_ARGUMENT],
-        functionArguments: [fungibleTokenAddress, recipientAddress, this.recipients[0].amount],
-        abi: faTransferAbi,
-      },
-      options: {
-        maxGasAmount: this.maxGasAmount,
-        gasUnitPrice: this.gasUnitPrice,
-        expireTimestamp: this.expirationTime,
-        accountSequenceNumber: this.sequenceNumber,
-      },
-    });
-    this._rawTransaction = simpleTxn.rawTransaction;
+    if (this.recipients.length > 1) {
+      return {
+        function: FUNGIBLE_ASSET_BATCH_TRANSFER_FUNCTION,
+        typeArguments: [],
+        functionArguments: [
+          fungibleTokenAddress,
+          this.recipients.map((recipient) => AccountAddress.fromString(recipient.address)),
+          this.recipients.map((recipient) => recipient.amount),
+        ],
+      };
+    }
+    return {
+      function: FUNGIBLE_ASSET_TRANSFER_FUNCTION,
+      typeArguments: [FUNGIBLE_ASSET_TYPE_ARGUMENT],
+      functionArguments: [
+        fungibleTokenAddress,
+        AccountAddress.fromString(this.recipients[0].address),
+        this.recipients[0].amount,
+      ],
+      abi: faTransferAbi,
+    };
+  }
+
+  private isValidPayload(payload: TransactionPayload) {
+    return (
+      payload instanceof TransactionPayloadEntryFunction &&
+      payload.entryFunction.args.length === 3 &&
+      (payload.entryFunction.type_args.length === 0 ||
+        (payload.entryFunction.type_args.length === 1 &&
+          FUNGIBLE_ASSET_TYPE_ARGUMENT === payload.entryFunction.type_args[0].toString()))
+    );
   }
 }

modules/sdk-coin-apt/src/lib/transaction/transaction.ts

@@ -7,19 +7,23 @@ import {
   TransactionRecipient,
   TransactionType,
 } from '@bitgo/sdk-core';
-import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseCoin as CoinConfig, NetworkType } from '@bitgo/statics';
 import {
   AccountAddress,
   AccountAuthenticator,
   AccountAuthenticatorEd25519,
   AccountAuthenticatorNoAccountAuthenticator,
+  Aptos,
+  AptosConfig,
   DEFAULT_MAX_GAS_AMOUNT,
   Ed25519PublicKey,
   Ed25519Signature,
   FeePayerRawTransaction,
   generateSigningMessage,
   generateUserTransactionHash,
   Hex,
+  InputGenerateTransactionPayloadData,
+  Network,
   RAW_TRANSACTION_SALT,
   RAW_TRANSACTION_WITH_DATA_SALT,
   RawTransaction,
@@ -179,7 +183,7 @@ export abstract class Transaction extends BaseTransaction {
     this._isSimulateTxn = value;
   }
 
-  protected abstract buildRawTransaction(): void;
+  protected abstract getTransactionPayloadData(): InputGenerateTransactionPayloadData;
 
   protected abstract parseTransactionPayload(payload: TransactionPayload): void;
 
@@ -374,6 +378,24 @@ export abstract class Transaction extends BaseTransaction {
     };
   }
 
+  protected async buildRawTransaction(): Promise<void> {
+    const network: Network = this._coinConfig.network.type === NetworkType.MAINNET ? Network.MAINNET : Network.TESTNET;
+    const aptos = new Aptos(new AptosConfig({ network }));
+    const senderAddress = AccountAddress.fromString(this._sender);
+
+    const simpleTxn = await aptos.transaction.build.simple({
+      sender: senderAddress,
+      data: this.getTransactionPayloadData() as InputGenerateTransactionPayloadData,
+      options: {
+        maxGasAmount: this.maxGasAmount,
+        gasUnitPrice: this.gasUnitPrice,
+        expireTimestamp: this.expirationTime,
+        accountSequenceNumber: this.sequenceNumber,
+      },
+    });
+    this._rawTransaction = simpleTxn.rawTransaction;
+  }
+
   private getSignablePayloadWithFeePayer(): Buffer {
     const feePayerRawTxn = new FeePayerRawTransaction(
       this._rawTransaction,

modules/sdk-coin-apt/src/lib/transaction/transferTransaction.ts

@@ -1,17 +1,13 @@
 import { Transaction } from './transaction';
-import { InvalidTransactionError, TransactionRecipient, TransactionType } from '@bitgo/sdk-core';
+import { InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
 import {
   AccountAddress,
-  Aptos,
-  AptosConfig,
-  EntryFunctionArgument,
   InputGenerateTransactionPayloadData,
-  Network,
   TransactionPayload,
   TransactionPayloadEntryFunction,
 } from '@aptos-labs/ts-sdk';
 
-import { BaseCoin as CoinConfig, NetworkType } from '@bitgo/statics';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { APTOS_COIN, COIN_BATCH_TRANSFER_FUNCTION, COIN_TRANSFER_FUNCTION } from '../constants';
 import utils from '../utils';
 
@@ -30,25 +26,25 @@ export class TransferTransaction extends Transaction {
     this._assetId = entryFunction.type_args[0].toString();
     const addressArg = entryFunction.args[0];
     const amountArg = entryFunction.args[1];
-    this.recipients = this.parseRecipients(addressArg, amountArg);
+    this.recipients = utils.parseRecipients(addressArg, amountArg);
   }
 
-  protected async buildRawTransaction(): Promise<void> {
-    const network: Network = this._coinConfig.network.type === NetworkType.MAINNET ? Network.MAINNET : Network.TESTNET;
-    const aptos = new Aptos(new AptosConfig({ network }));
-    const senderAddress = AccountAddress.fromString(this._sender);
-
-    const simpleTxn = await aptos.transaction.build.simple({
-      sender: senderAddress,
-      data: this.buildData(this.recipients) as InputGenerateTransactionPayloadData,
-      options: {
-        maxGasAmount: this.maxGasAmount,
-        gasUnitPrice: this.gasUnitPrice,
-        expireTimestamp: this.expirationTime,
-        accountSequenceNumber: this.sequenceNumber,
-      },
-    });
-    this._rawTransaction = simpleTxn.rawTransaction;
+  protected getTransactionPayloadData(): InputGenerateTransactionPayloadData {
+    if (this.recipients.length > 1) {
+      return {
+        function: COIN_BATCH_TRANSFER_FUNCTION,
+        typeArguments: [this.assetId],
+        functionArguments: [
+          this.recipients.map((recipient) => AccountAddress.fromString(recipient.address)),
+          this.recipients.map((recipient) => recipient.amount),
+        ],
+      };
+    }
+    return {
+      function: COIN_TRANSFER_FUNCTION,
+      typeArguments: [this.assetId],
+      functionArguments: [AccountAddress.fromString(this.recipients[0].address), this.recipients[0].amount],
+    };
   }
 
   private isValidPayload(payload: TransactionPayload): boolean {
@@ -59,34 +55,4 @@ export class TransferTransaction extends Transaction {
       payload.entryFunction.type_args[0].toString().length > 0
     );
   }
-
-  private parseRecipients(addressArg: EntryFunctionArgument, amountArg: EntryFunctionArgument): TransactionRecipient[] {
-    const { recipients, isValid } = utils.fetchAndValidateRecipients(addressArg, amountArg);
-    if (!isValid) {
-      throw new InvalidTransactionError('Invalid transaction recipients');
-    }
-    return recipients.deserializedAddresses.map((address, index) => ({
-      address,
-      amount: utils.getAmountFromPayloadArgs(recipients.deserializedAmounts[index]),
-    })) as TransactionRecipient[];
-  }
-
-  private buildData(recipients: TransactionRecipient[]): InputGenerateTransactionPayloadData {
-    if (recipients.length > 1) {
-      return {
-        function: COIN_BATCH_TRANSFER_FUNCTION,
-        typeArguments: [this.assetId],
-        functionArguments: [
-          recipients.map((recipient) => AccountAddress.fromString(recipient.address)),
-          recipients.map((recipient) => recipient.amount),
-        ],
-      };
-    } else {
-      return {
-        function: COIN_TRANSFER_FUNCTION,
-        typeArguments: [this.assetId],
-        functionArguments: [AccountAddress.fromString(recipients[0].address), recipients[0].amount],
-      };
-    }
-  }
 }

modules/sdk-coin-apt/src/lib/transactionBuilder/fungibleAssetTransferBuilder.ts

@@ -2,7 +2,6 @@ import { TransactionBuilder } from './transactionBuilder';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { FungibleAssetTransfer } from '../transaction/fungibleAssetTransfer';
 import { TransactionType } from '@bitgo/sdk-core';
-import BigNumber from 'bignumber.js';
 import utils from '../utils';
 import { TransactionPayload, TransactionPayloadEntryFunction } from '@aptos-labs/ts-sdk';
 import { FUNGIBLE_ASSET_TYPE_ARGUMENT } from '../constants';
@@ -34,28 +33,30 @@ export class FungibleAssetTransferBuilder extends TransactionBuilder {
 
   protected isValidTransactionPayload(payload: TransactionPayload) {
     try {
-      if (
-        !(payload instanceof TransactionPayloadEntryFunction) ||
-        payload.entryFunction.args.length !== 3 ||
-        payload.entryFunction.type_args.length !== 1 ||
-        FUNGIBLE_ASSET_TYPE_ARGUMENT !== payload.entryFunction.type_args[0].toString()
-      ) {
+      if (!this.isValidPayload(payload)) {
         console.error('invalid transaction payload');
         return false;
       }
-      const entryFunction = payload.entryFunction;
+      const entryFunction = (payload as TransactionPayloadEntryFunction).entryFunction;
       const fungibleTokenAddress = entryFunction.args[0].toString();
-      const recipientAddress = entryFunction.args[1].toString();
-      const amountBuffer = Buffer.from(entryFunction.args[2].bcsToBytes());
-      const recipientAmount = new BigNumber(amountBuffer.readBigUint64LE().toString());
+      const addressArg = entryFunction.args[1];
+      const amountArg = entryFunction.args[2];
       return (
-        utils.isValidAddress(recipientAddress) &&
-        utils.isValidAddress(fungibleTokenAddress) &&
-        !recipientAmount.isLessThan(0)
+        utils.isValidAddress(fungibleTokenAddress) && utils.fetchAndValidateRecipients(addressArg, amountArg).isValid
       );
     } catch (e) {
       console.error('invalid transaction payload', e);
       return false;
     }
   }
+
+  private isValidPayload(payload: TransactionPayload) {
+    return (
+      payload instanceof TransactionPayloadEntryFunction &&
+      payload.entryFunction.args.length === 3 &&
+      (payload.entryFunction.type_args.length === 0 ||
+        (payload.entryFunction.type_args.length === 1 &&
+          FUNGIBLE_ASSET_TYPE_ARGUMENT === payload.entryFunction.type_args[0].toString()))
+    );
+  }
 }