@ledgerhq/coin-aptos 1.10.0-nightly.2 → 1.10.0-nightly.3

package/src/__tests__/api/craftTransaction.unit.test.ts

@@ -1,9 +1,9 @@
-import { Hex, type InputEntryFunctionData, RawTransaction, Deserializer } from "@aptos-labs/ts-sdk";
+import { Hex, RawTransaction, Deserializer } from "@aptos-labs/ts-sdk";
 import type { TransactionIntent } from "@ledgerhq/coin-framework/lib/api/types";
 import { createApi } from "../../api";
-import type { TransactionOptions } from "../../types";
 import type { AptosAsset, AptosExtra, AptosSender } from "../../types/assets";
 import { AptosAPI } from "../../network";
+import { APTOS_ASSET_ID } from "../../constants";
 
 jest.mock("../../network");
 let mockedAptosApi: jest.Mocked<any>;
@@ -12,7 +12,7 @@ jest.mock("../../config", () => ({
   setCoinConfig: jest.fn(),
 }));
 
-describe("returns a valid transaction", () => {
+describe("craftTransaction", () => {
   beforeEach(() => {
     mockedAptosApi = jest.mocked(AptosAPI);
   });
@@ -21,29 +21,113 @@ describe("returns a valid transaction", () => {
     jest.resetAllMocks();
   });
 
-  it("creates a valid transaction", async () => {
-    const SENDER_ADDR = "APTOS_1_ADDRESS";
-    const RECIPIENT_ADDR = "APTOS_2_ADDRESS";
+  const SENDER_ADDR = "APTOS_1_ADDRESS";
+  const RECIPIENT_ADDR = "APTOS_2_ADDRESS";
 
-    const hexRawTx =
-      "0xfdde1012c0fac1f9a121eb3c8481c90d473df1c4180c070bd4f2549a6d06180400000000000000000200000000000000000000000000000000000000000000000000000000000000010d6170746f735f6163636f756e74087472616e736665720002203f5f0fcc8a909f23806e5efbdc1757e653fcd744de516a7de12b99b8417925c1080a00000000000000400d03000000000064000000000000002c721b6800000000b7";
-    const rawTxn = RawTransaction.deserialize(
-      new Deserializer(Hex.fromHexString(hexRawTx).toUint8Array()),
+  const hexRawTx =
+    "0xfdde1012c0fac1f9a121eb3c8481c90d473df1c4180c070bd4f2549a6d06180400000000000000000200000000000000000000000000000000000000000000000000000000000000010d6170746f735f6163636f756e74087472616e736665720002203f5f0fcc8a909f23806e5efbdc1757e653fcd744de516a7de12b99b8417925c1080a00000000000000400d03000000000064000000000000002c721b6800000000b7";
+
+  const rawTxn = RawTransaction.deserialize(
+    new Deserializer(Hex.fromHexString(hexRawTx).toUint8Array()),
+  );
+
+  it("creates a coin transaction", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: APTOS_ASSET_ID, amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 10n,
+      asset: { type: "native" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(0);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::aptos_account::transfer_coins",
+        typeArguments: [APTOS_ASSET_ID],
+        functionArguments: [RECIPIENT_ADDR, txArg.amount.toString()],
+      }),
+      expect.anything(),
     );
+  });
 
-    const mockGenerateTransaction = jest
+  it("creates a native coin transaction using all amount available", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
       .fn()
-      .mockImplementation(
-        (_address: string, _payload: InputEntryFunctionData, _options: TransactionOptions) =>
-          Promise.resolve(rawTxn),
-      );
+      .mockResolvedValue([{ contractAddress: APTOS_ASSET_ID, amount: 12345 }]);
     mockedAptosApi.mockImplementation(() => ({
       generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
     }));
-    const mockGenerateTransactionSpy = jest.spyOn(
-      { generateTransaction: mockGenerateTransaction },
-      "generateTransaction",
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 0n,
+      asset: { type: "native" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(1);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::aptos_account::transfer_coins",
+        typeArguments: [APTOS_ASSET_ID],
+        functionArguments: [RECIPIENT_ADDR, "12345"],
+      }),
+      expect.anything(),
     );
+  });
+
+  it("creates a coin token transaction", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: "0x42::token::Token", amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
 
     const SENDER: AptosSender = {
       xpub: "public-key",
@@ -58,13 +142,102 @@ describe("returns a valid transaction", () => {
       sender: SENDER,
       recipient: RECIPIENT_ADDR,
       amount: 10n,
-      asset: { type: "native" },
+      asset: { type: "token", standard: "coin", contractAddress: "0x42::token::Token" },
     };
 
     const tx = await api.craftTransaction(txArg);
 
     expect(tx).not.toEqual("");
     expect(Hex.isValid(tx).valid).toBeTruthy();
-    expect(mockGenerateTransactionSpy).toHaveBeenCalledTimes(1);
+    expect(mockGetBalances).toHaveBeenCalledTimes(0);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::aptos_account::transfer_coins",
+        typeArguments: ["0x42::token::Token"],
+        functionArguments: [RECIPIENT_ADDR, txArg.amount.toString()],
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("creates a fungible_asset token transaction using all amount available", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: "0x42", amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 0n,
+      asset: { type: "token", standard: "fungible_asset", contractAddress: "0x42" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(1);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::primary_fungible_store::transfer",
+        typeArguments: ["0x1::fungible_asset::Metadata"],
+        functionArguments: ["0x42", RECIPIENT_ADDR, "12345"],
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("throws an exception for invalid tokenType", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: "0x42::token::Token", amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 10n,
+      asset: { type: "token", standard: "asset", contractAddress: "0x42::token::Token" },
+    };
+
+    expect(async () => await api.craftTransaction(txArg)).rejects.toThrow(
+      "Token type asset not supported",
+    );
+
+    expect(mockGetBalances).toHaveBeenCalledTimes(0);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(0);
   });
 });

package/src/__tests__/api/index.integ.test.ts

@@ -22,6 +22,11 @@ describe("createApi", () => {
     freshAddress: "0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb",
   };
 
+  const tokenAccount: AptosSender = {
+    xpub: "eacada8192f15185637e475d7783e14486e232d8b9978ffa127383847ffc5318",
+    freshAddress: "0xb8922507317d85197d70c2bc1afc949c759fd0a62c8841a4300d1e2b63649bf6",
+  };
+
   describe("lastBlock", () => {
     it("returns the last block information", async () => {
       const lastBlock = await api.lastBlock();
@@ -33,6 +38,7 @@ describe("createApi", () => {
       expect(lastBlock.height).toBeGreaterThan(0);
 
       expect(lastBlock).toHaveProperty("time");
+
       expect(lastBlock.time).not.toBeUndefined();
       expect(lastBlock.time?.getFullYear()).toBeGreaterThan(0);
       expect(lastBlock.time?.getMonth()).toBeGreaterThan(0);
@@ -59,7 +65,7 @@ describe("createApi", () => {
   });
 
   describe("craftTransaction", () => {
-    it("returns a RawTransaction serialized into an hexadecimal string", async () => {
+    it("returns a native coin RawTransaction serialized into an hexadecimal string", async () => {
       const hex = await api.craftTransaction(
         {
           amount: 1n,
@@ -79,6 +85,85 @@ describe("createApi", () => {
       expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
       expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
     });
+
+    it("returns a coin token RawTransaction serialized into an hexadecimal string", async () => {
+      const hex = await api.craftTransaction(
+        {
+          amount: 1n,
+          sender: sender,
+          recipient: recipient.freshAddress,
+          type: "send",
+          asset: {
+            type: "token",
+            standard: "coin",
+            contractAddress:
+              "0x50788befc1107c0cc4473848a92e5c783c635866ce3c98de71d2eeb7d2a34f85::aptos_coin::AptosCoin",
+          },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(sender.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
+
+    it("returns a use-all-amount coin token RawTransaction serialized into an hexadecimal string", async () => {
+      const hex = await api.craftTransaction(
+        {
+          amount: 0n,
+          sender: sender,
+          recipient: recipient.freshAddress,
+          type: "send",
+          asset: {
+            type: "token",
+            standard: "coin",
+            contractAddress:
+              "0x50788befc1107c0cc4473848a92e5c783c635866ce3c98de71d2eeb7d2a34f85::aptos_coin::AptosCoin",
+          },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(sender.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
+
+    it("returns a use-all-amount fungible_asset token RawTransaction serialized into an hexadecimal string", async () => {
+      const r = sender;
+      const s = recipient; // recipient contains fungible_assets balances
+      const hex = await api.craftTransaction(
+        {
+          amount: 0n,
+          sender: s,
+          recipient: r.freshAddress,
+          type: "send",
+          asset: {
+            type: "token",
+            standard: "fungible_asset",
+            contractAddress: "0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+          },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(s.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
   });
 
   describe("getBalance", () => {
@@ -86,7 +171,7 @@ describe("createApi", () => {
       const balances = await api.getBalance(sender.freshAddress);
 
       expect(balances.length).toBeGreaterThan(0);
-      expect(balances[0].value).toBeGreaterThan(0);
+      expect(balances[0].value).toBeGreaterThanOrEqual(0);
     });
   });
 
@@ -136,4 +221,143 @@ describe("createApi", () => {
       });
     });
   });
+
+  describe("listOperationsTokens", () => {
+    it("returns operations from account", async () => {
+      const block = await api.lastBlock();
+
+      const [operations] = await api.listOperations(tokenAccount.freshAddress, {
+        minHeight: block.height,
+      });
+
+      expect(operations).toBeInstanceOf(Array);
+      expect(operations.length).toBeGreaterThanOrEqual(1);
+
+      const txINNativeHash = "0xd841b502ce333e5b9ac394db81e6597d9bbbe475e5b12966b98b843d91cc0a09";
+      const txOUTNativeHash = "0xb1114396c5b6f2f5ba955fa8e4102d0e3983d5ccdb0717ff792f6e4848e72366";
+
+      const txINLegacyCoinHash =
+        "0x6869c933396d976af85b273a825fe264a910d0064fe28ce97285073b9e5306bb";
+      const txOUTLegacyCoinHash =
+        "0xa720db7fe6327b1db23e778df5856ab1d8785d7e8edae98941a3f6e05fa58ddd";
+
+      const txINFungibleAssetHash =
+        "0x88856968603dee4f08579036bc30322b9a5f329561656888e3467ce27cc11ea7";
+      const txOUTFungibleAssetHash =
+        "0x8aa9e980760fe8aeb6804f387350b3019a2471aa61a5506a260c32cd5d6db32c";
+
+      const operationIN = operations.find(operation => operation.id === txINNativeHash);
+      const operationOUT = operations.find(operation => operation.id === txOUTNativeHash);
+
+      expect(operationIN).toMatchObject({
+        type: "IN",
+        value: 1000000n,
+        recipients: [tokenAccount.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: { type: "native" },
+        tx: {
+          hash: "0xd841b502ce333e5b9ac394db81e6597d9bbbe475e5b12966b98b843d91cc0a09",
+          block: { height: 0 },
+          fees: 99900n,
+          date: new Date("2025-05-29T18:32:11.515Z"),
+        },
+      });
+
+      expect(operationOUT).toMatchObject({
+        type: "OUT",
+        value: 951100n,
+        recipients: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        senders: [tokenAccount.freshAddress],
+        asset: { type: "native" },
+        tx: {
+          hash: "0xb1114396c5b6f2f5ba955fa8e4102d0e3983d5ccdb0717ff792f6e4848e72366",
+          block: { height: 0 },
+          fees: 1100n,
+          date: new Date("2025-05-29T18:39:57.864Z"),
+        },
+      });
+
+      const coinIN = operations.find(operation => operation.id === txINLegacyCoinHash);
+      const coinOUT = operations.find(operation => operation.id === txOUTLegacyCoinHash);
+
+      expect(coinIN).toMatchObject({
+        type: "IN",
+        value: 2000000n,
+        recipients: [tokenAccount.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: {
+          type: "token",
+          asset_type: "coin",
+          address:
+            "0xd11107bdf0d6d7040c6c0bfbdecb6545191fdf13e8d8d259952f53e1713f61b5::staked_coin::StakedAptos",
+        },
+        tx: {
+          hash: "0x6869c933396d976af85b273a825fe264a910d0064fe28ce97285073b9e5306bb",
+          block: { height: 0 },
+          fees: 51100n,
+          date: new Date("2025-05-29T18:32:58.804Z"),
+        },
+      });
+
+      expect(coinOUT).toMatchObject({
+        type: "OUT",
+        value: 1000000n,
+        recipients: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        senders: [tokenAccount.freshAddress],
+        asset: {
+          type: "token",
+          asset_type: "coin",
+          address:
+            "0xd11107bdf0d6d7040c6c0bfbdecb6545191fdf13e8d8d259952f53e1713f61b5::staked_coin::StakedAptos",
+        },
+        tx: {
+          hash: "0xa720db7fe6327b1db23e778df5856ab1d8785d7e8edae98941a3f6e05fa58ddd",
+          block: { height: 0 },
+          fees: 1200n,
+          date: new Date("2025-05-29T18:38:08.283Z"),
+        },
+      });
+
+      const fungibleAssetIN = operations.find(operation => operation.id === txINFungibleAssetHash);
+      const fungibleAssetOUT = operations.find(
+        operation => operation.id === txOUTFungibleAssetHash,
+      );
+
+      expect(fungibleAssetIN).toMatchObject({
+        type: "IN",
+        value: 1750n,
+        recipients: [tokenAccount.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: {
+          type: "token",
+          asset_type: "fungible_asset",
+          address: "0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+        },
+        tx: {
+          hash: "0x88856968603dee4f08579036bc30322b9a5f329561656888e3467ce27cc11ea7",
+          block: { height: 0 },
+          fees: 54300n,
+          date: new Date("2025-05-29T18:33:58.097Z"),
+        },
+      });
+
+      expect(fungibleAssetOUT).toMatchObject({
+        type: "OUT",
+        value: 1000n,
+        recipients: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        senders: [tokenAccount.freshAddress],
+        asset: {
+          type: "token",
+          asset_type: "fungible_asset",
+          address: "0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+        },
+        tx: {
+          hash: "0x8aa9e980760fe8aeb6804f387350b3019a2471aa61a5506a260c32cd5d6db32c",
+          block: { height: 0 },
+          fees: 1000n,
+          date: new Date("2025-05-29T18:38:56.897Z"),
+        },
+      });
+    });
+  });
 });

package/src/__tests__/logic/buildTransaction.test.ts

@@ -19,12 +19,14 @@ jest.mock("../../logic/normalizeTransactionOptions", () => ({
   })),
 }));
 
-jest.mock("../../constants", () => ({
-  DEFAULT_GAS: 100,
-  DEFAULT_GAS_PRICE: 200,
-  APTOS_ASSET_ID: "0x1::aptos_coin::AptosCoin",
-  SUPPORTED_TOKEN_TYPES: ["coin", "fungible_asset"],
-}));
+jest.mock("../../constants", () => {
+  const originalModules = jest.requireActual("../../constants");
+  return {
+    ...originalModules,
+    DEFAULT_GAS: 100,
+    DEFAULT_GAS_PRICE: 200,
+  };
+});
 
 jest.mock("../../network", () => {
   return {

package/src/__tests__/network/client.test.ts

@@ -654,7 +654,7 @@ describe("Aptos API", () => {
         },
       });
       expect(balances).toHaveLength(1);
-      expect(balances[0].asset_type).toBe(assets[0].asset_type);
+      expect(balances[0].contractAddress).toBe(assets[0].asset_type);
       expect(balances[0].amount).toStrictEqual(BigNumber(assets[0].amount));
     });
   });

package/src/constants.ts

@@ -45,6 +45,10 @@ export enum DIRECTION {
   UNKNOWN = "UNKNOWN",
 }
 
-export const SUPPORTED_TOKEN_TYPES = ["coin", "fungible_asset"];
+export enum TOKEN_TYPE {
+  COIN = "coin",
+  FUNGIBLE_ASSET = "fungible_asset",
+}
+
 export const DEFAULT_GAS = new BigNumber(200);
 export const DEFAULT_GAS_PRICE = new BigNumber(100);

package/src/logic/buildTransaction.ts

@@ -1,62 +1,70 @@
-import { InputEntryFunctionData, RawTransaction } from "@aptos-labs/ts-sdk";
-import type { Account, TokenAccount } from "@ledgerhq/types-live";
-import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/index";
-import { APTOS_ASSET_ID, SUPPORTED_TOKEN_TYPES } from "../constants";
+import type { InputEntryFunctionData, RawTransaction } from "@aptos-labs/ts-sdk";
+import type { Account } from "@ledgerhq/types-live";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import { APTOS_ASSET_ID, TOKEN_TYPE } from "../constants";
 import type { AptosAPI } from "../network";
 import { normalizeTransactionOptions } from "./normalizeTransactionOptions";
 import type { Transaction } from "../types";
+import type BigNumber from "bignumber.js";
 
 const buildTransaction = async (
   account: Account,
   transaction: Transaction,
   aptosClient: AptosAPI,
+  contractAddress?: string,
+  tokenType?: TOKEN_TYPE,
 ): Promise<RawTransaction> => {
   const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
 
-  const txPayload = getPayload(subAccount, transaction);
+  const payloadContracAddress = subAccount ? subAccount.token.contractAddress : contractAddress;
+  const payloadTokenType = (subAccount?.token?.tokenType as TOKEN_TYPE) ?? tokenType;
+
+  const txPayload = getPayload({
+    amount: transaction.amount,
+    recipient: transaction.recipient,
+    contractAddress: payloadContracAddress,
+    tokenType: payloadTokenType,
+  });
+
   const txOptions = normalizeTransactionOptions(transaction.options);
+
   const tx = await aptosClient.generateTransaction(account.freshAddress, txPayload, txOptions);
 
   return tx;
 };
 
-const getPayload = (
-  tokenAccount: TokenAccount | undefined,
-  transaction: Transaction,
-): InputEntryFunctionData => {
-  if (tokenAccount && isTokenAccount(tokenAccount)) {
-    const { tokenType } = tokenAccount.token;
-
-    if (!SUPPORTED_TOKEN_TYPES.includes(tokenType)) {
-      throw new Error(`Token type ${tokenType} not supported`);
-    }
-
-    if (tokenType === "fungible_asset") {
-      return {
-        function: `0x1::primary_fungible_store::transfer`,
-        typeArguments: ["0x1::fungible_asset::Metadata"],
-        functionArguments: [
-          tokenAccount.token.contractAddress,
-          transaction.recipient,
-          transaction.amount.toString(),
-        ],
-      };
-    }
-
-    if (tokenType === "coin") {
-      return {
-        function: `0x1::aptos_account::transfer_coins`,
-        typeArguments: [tokenAccount.token.contractAddress],
-        functionArguments: [transaction.recipient, transaction.amount.toString()],
-      };
-    }
+const getPayload = (args: {
+  amount: BigNumber;
+  recipient: string;
+  contractAddress?: string | undefined;
+  tokenType?: string;
+}): InputEntryFunctionData => {
+  if (args.tokenType !== undefined && !isTokenType(args.tokenType)) {
+    throw new Error(`Token type ${args.tokenType} not supported`);
+  }
+
+  if (args.tokenType === TOKEN_TYPE.FUNGIBLE_ASSET) {
+    return {
+      function: "0x1::primary_fungible_store::transfer",
+      typeArguments: ["0x1::fungible_asset::Metadata"],
+      functionArguments: [args.contractAddress, args.recipient, args.amount.toString()],
+    };
+  }
+
+  let address = args.contractAddress ?? "";
+  if (address === "") {
+    address = APTOS_ASSET_ID;
   }
 
   return {
     function: "0x1::aptos_account::transfer_coins",
-    typeArguments: [APTOS_ASSET_ID],
-    functionArguments: [transaction.recipient, transaction.amount.toString()],
+    typeArguments: [address],
+    functionArguments: [args.recipient, args.amount.toString()],
   };
 };
 
+export const isTokenType = (value: string): boolean => {
+  return Object.values(TOKEN_TYPE).includes(value as TOKEN_TYPE);
+};
+
 export default buildTransaction;