@ledgerhq/coin-aptos 1.9.6-next.0 → 2.0.0-nightly.1

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

@@ -1,499 +1,80 @@
-import { ApolloClient } from "@apollo/client";
-import {
-  AccountAddress,
-  Aptos,
-  ChainId,
-  Ed25519PublicKey,
-  InputEntryFunctionData,
-  RawTransaction,
-  Serializable,
-  post,
-} from "@aptos-labs/ts-sdk";
-import network from "@ledgerhq/live-network";
-import BigNumber from "bignumber.js";
-import { AptosAPI } from "../../api";
+import { Aptos } from "@aptos-labs/ts-sdk";
+import type { Api } from "@ledgerhq/coin-framework/api/types";
+import type { AptosAsset } from "../../types/assets";
+import type { AptosConfig } from "../../config";
+import { createApi } from "../../api";
+import coinConfig from "../../config";
 
 jest.mock("@aptos-labs/ts-sdk");
-jest.mock("@apollo/client");
 let mockedAptos: jest.Mocked<any>;
-let mockedApolloClient: jest.Mocked<any>;
-let mockedPost = jest.fn();
 
-jest.mock("@ledgerhq/live-network/network");
-const mockedNetwork = jest.mocked(network);
+jest.mock("../../config", () => ({
+  setCoinConfig: jest.fn(),
+}));
 
-describe("Aptos API", () => {
-  beforeEach(() => {
-    mockedAptos = jest.mocked(Aptos);
-    mockedApolloClient = jest.mocked(ApolloClient);
-    mockedPost = jest.mocked(post);
-  });
+const mockAptosConfig: AptosConfig = {} as AptosConfig;
 
-  afterEach(() => jest.clearAllMocks());
+describe("createApi", () => {
+  it("should set the coin config value", () => {
+    const setCoinConfigSpy = jest.spyOn(coinConfig, "setCoinConfig");
 
-  it("builds the client properly for mainnet", () => {
-    const api = new AptosAPI("aptos");
+    createApi(mockAptosConfig);
 
-    expect(api.broadcast).toBeDefined();
-    expect(typeof api.broadcast).toBe("function");
-    expect(api.estimateGasPrice).toBeDefined();
-    expect(typeof api.estimateGasPrice).toBe("function");
-    expect(api.generateTransaction).toBeDefined();
-    expect(typeof api.generateTransaction).toBe("function");
-    expect(api.getAccount).toBeDefined();
-    expect(typeof api.getAccount).toBe("function");
-    expect(api.getAccountInfo).toBeDefined();
-    expect(typeof api.getAccountInfo).toBe("function");
-    expect(api.simulateTransaction).toBeDefined();
-    expect(typeof api.simulateTransaction).toBe("function");
-  });
+    const config = setCoinConfigSpy.mock.calls[0][0]();
 
-  it("builds the client properly for testnet", () => {
-    const api = new AptosAPI("aptos_testnet");
+    expect(setCoinConfigSpy).toHaveBeenCalled();
 
-    expect(api.broadcast).toBeDefined();
-    expect(typeof api.broadcast).toBe("function");
-    expect(api.estimateGasPrice).toBeDefined();
-    expect(typeof api.estimateGasPrice).toBe("function");
-    expect(api.generateTransaction).toBeDefined();
-    expect(typeof api.generateTransaction).toBe("function");
-    expect(api.getAccount).toBeDefined();
-    expect(typeof api.getAccount).toBe("function");
-    expect(api.getAccountInfo).toBeDefined();
-    expect(typeof api.getAccountInfo).toBe("function");
-    expect(api.simulateTransaction).toBeDefined();
-    expect(typeof api.simulateTransaction).toBe("function");
+    expect(config).toEqual(
+      expect.objectContaining({
+        ...mockAptosConfig,
+        status: { type: "active" },
+      }),
+    );
   });
 
-  describe("getAccount", () => {
-    it("calls getAccountInfo", async () => {
-      const mockGetAccountInfo = jest.fn();
-      mockedAptos.mockImplementation(() => ({
-        getAccountInfo: mockGetAccountInfo,
-      }));
-
-      const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
-
-      const api = new AptosAPI("aptos");
-      await api.getAccount("address");
-
-      expect(mockGetAccountSpy).toHaveBeenCalledWith({
-        accountAddress: "address",
-      });
-    });
-  });
-
-  describe("getAccountInfo", () => {
-    it("calls getBalance, fetchTransactions and getHeight", async () => {
-      mockedAptos.mockImplementation(() => ({
-        view: jest.fn().mockReturnValue(["123"]),
-        getTransactionByVersion: jest.fn().mockReturnValue({
-          type: "user_transaction",
-          version: "v1",
-        }),
-        getBlockByVersion: jest.fn().mockReturnValue({
-          block_height: "1",
-          block_hash: "83ca6d",
-        }),
-      }));
-
-      mockedNetwork.mockResolvedValue(
-        Promise.resolve({
-          data: {
-            account: {
-              account_number: 1,
-              sequence: 0,
-              pub_key: { key: "k", "@type": "type" },
-              base_account: {
-                account_number: 2,
-                sequence: 42,
-                pub_key: { key: "k2", "@type": "type2" },
-              },
-            },
-            block_height: "999",
-          },
-          status: 200,
-          headers: {} as any,
-          statusText: "",
-          config: {
-            headers: {} as any,
-          },
-        }),
-      );
-
-      mockedApolloClient.mockImplementation(() => ({
-        query: async () => ({
-          data: {
-            address_version_from_move_resources: [{ transaction_version: "v1" }],
-          },
-          loading: false,
-          networkStatus: 7,
-        }),
-      }));
-
-      const api = new AptosAPI("aptos");
-      const accountInfo = await api.getAccountInfo("APTOS_1_ADDRESS", "1");
-
-      expect(accountInfo.balance).toEqual(new BigNumber(123));
-      expect(accountInfo.transactions).toEqual([
-        {
-          type: "user_transaction",
-          version: "v1",
-          block: {
-            height: 1,
-            hash: "83ca6d",
-          },
-        },
-      ]);
-      expect(accountInfo.blockHeight).toEqual(999);
-    });
-
-    it("return balance = 0 if it fails to fetch balance", async () => {
-      mockedAptos.mockImplementation(() => ({
-        view: jest.fn().mockImplementation(() => {
-          throw new Error("error");
-        }),
-        getTransactionByVersion: jest.fn().mockReturnValue({
-          type: "user_transaction",
-          version: "v1",
-        }),
-        getBlockByVersion: jest.fn().mockReturnValue({
-          block_height: "1",
-          block_hash: "83ca6d",
-        }),
-      }));
-
-      mockedNetwork.mockResolvedValue(
-        Promise.resolve({
-          data: {
-            account: {
-              account_number: 1,
-              sequence: 0,
-              pub_key: { key: "k", "@type": "type" },
-              base_account: {
-                account_number: 2,
-                sequence: 42,
-                pub_key: { key: "k2", "@type": "type2" },
-              },
-            },
-            block_height: "999",
-          },
-          status: 200,
-          headers: {} as any,
-          statusText: "",
-          config: {
-            headers: {} as any,
-          },
-        }),
-      );
-
-      mockedApolloClient.mockImplementation(() => ({
-        query: async () => ({
-          data: {
-            address_version_from_move_resources: [{ transaction_version: "v1" }],
-          },
-          loading: false,
-          networkStatus: 7,
-        }),
-      }));
-
-      const api = new AptosAPI("aptos");
-      const accountInfo = await api.getAccountInfo("APTOS_1_ADDRESS", "1");
-
-      expect(accountInfo.balance).toEqual(new BigNumber(0));
-      expect(accountInfo.transactions).toEqual([
-        {
-          type: "user_transaction",
-          version: "v1",
-          block: {
-            height: 1,
-            hash: "83ca6d",
-          },
-        },
-      ]);
-      expect(accountInfo.blockHeight).toEqual(999);
-    });
-
-    it("returns no transactions if it the address is empty", async () => {
-      mockedAptos.mockImplementation(() => ({
-        view: jest.fn().mockReturnValue(["123"]),
-        getTransactionByVersion: jest.fn().mockReturnValue({
-          type: "user_transaction",
-          version: "v1",
-        }),
-        getBlockByVersion: jest.fn().mockReturnValue({
-          block_height: "1",
-          block_hash: "83ca6d",
-        }),
-      }));
-
-      mockedNetwork.mockResolvedValue(
-        Promise.resolve({
-          data: {
-            account: {
-              account_number: 1,
-              sequence: 0,
-              pub_key: { key: "k", "@type": "type" },
-              base_account: {
-                account_number: 2,
-                sequence: 42,
-                pub_key: { key: "k2", "@type": "type2" },
-              },
-            },
-            block_height: "999",
-          },
-          status: 200,
-          headers: {} as any,
-          statusText: "",
-          config: {
-            headers: {} as any,
-          },
-        }),
-      );
-
-      mockedApolloClient.mockImplementation(() => ({
-        query: async () => ({
-          data: {
-            address_version_from_move_resources: [{ transaction_version: "v1" }],
-          },
-          loading: false,
-          networkStatus: 7,
-        }),
-      }));
-
-      const api = new AptosAPI("aptos");
-      const accountInfo = await api.getAccountInfo("", "1");
-
-      expect(accountInfo.balance).toEqual(new BigNumber(123));
-      expect(accountInfo.transactions).toEqual([]);
-      expect(accountInfo.blockHeight).toEqual(999);
-    });
-
-    it("returns a null transaction if it fails to getTransactionByVersion", async () => {
-      mockedAptos.mockImplementation(() => ({
-        view: jest.fn().mockReturnValue(["123"]),
-        getTransactionByVersion: jest.fn().mockImplementation(() => {
-          throw new Error("error");
-        }),
-        getBlockByVersion: jest.fn().mockReturnValue({
-          block_height: "1",
-          block_hash: "83ca6d",
-        }),
-      }));
-
-      mockedNetwork.mockResolvedValue(
-        Promise.resolve({
-          data: {
-            account: {
-              account_number: 1,
-              sequence: 0,
-              pub_key: { key: "k", "@type": "type" },
-              base_account: {
-                account_number: 2,
-                sequence: 42,
-                pub_key: { key: "k2", "@type": "type2" },
-              },
-            },
-            block_height: "999",
-          },
-          status: 200,
-          headers: {} as any,
-          statusText: "",
-          config: {
-            headers: {} as any,
-          },
-        }),
-      );
-
-      mockedApolloClient.mockImplementation(() => ({
-        query: async () => ({
-          data: {
-            address_version_from_move_resources: [{ transaction_version: "v1" }],
-          },
-          loading: false,
-          networkStatus: 7,
-        }),
-      }));
-
-      const api = new AptosAPI("aptos");
-      const accountInfo = await api.getAccountInfo("APTOS_1_ADDRESS", "1");
+  it("should return an API object with alpaca api methods", () => {
+    const api: Api<AptosAsset> = createApi(mockAptosConfig);
 
-      expect(accountInfo.balance).toEqual(new BigNumber(123));
-      expect(accountInfo.transactions).toEqual([null]);
-      expect(accountInfo.blockHeight).toEqual(999);
-    });
-  });
-
-  describe("estimateGasPrice", () => {
-    it("estimates the gas price", async () => {
-      const gasEstimation = { gas_estimate: 100 };
-      mockedAptos.mockImplementation(() => ({
-        getGasPriceEstimation: jest.fn().mockReturnValue(gasEstimation),
-      }));
-
-      const api = new AptosAPI("aptos");
-      const gasPrice = await api.estimateGasPrice();
-
-      expect(gasPrice.gas_estimate).toEqual(100);
-    });
+    // Check that methods are set with what we expect
+    expect(api.broadcast).toBeDefined();
+    expect(api.combine).toBeDefined();
+    expect(api.craftTransaction).toBeDefined();
+    expect(api.estimateFees).toBeDefined();
+    expect(api.getBalance).toBeDefined();
+    expect(api.lastBlock).toBeDefined();
+    expect(api.listOperations).toBeDefined();
   });
+});
 
-  describe("generateTransaction", () => {
-    const payload: InputEntryFunctionData = {
-      function: "0x1::coin::transfer",
-      functionArguments: ["0x13", 1],
-    };
-
-    it("generates a transaction without expireTimestamp", async () => {
-      const options = {
-        maxGasAmount: "100",
-        gasUnitPrice: "50",
-      };
-
-      const mockSimple = jest.fn().mockImplementation(async () => ({
-        rawTransaction: null,
-      }));
-      mockedAptos.mockImplementation(() => ({
-        transaction: {
-          build: {
-            simple: mockSimple,
-          },
-        },
-      }));
-
-      const mockSimpleSpy = jest.spyOn({ simple: mockSimple }, "simple");
-
-      const api = new AptosAPI("aptos");
-      await api.generateTransaction("APTOS_1_ADDRESS", payload, options);
-
-      expect(mockSimpleSpy).toHaveBeenCalledWith({
-        data: payload,
-        options: {
-          maxGasAmount: Number(options.maxGasAmount),
-          gasUnitPrice: Number(options.gasUnitPrice),
-        },
-        sender: "APTOS_1_ADDRESS",
-      });
-    });
-
-    it("generates a transaction with default expireTimestamp", async () => {
-      const options = {
-        maxGasAmount: "100",
-        gasUnitPrice: "50",
-      };
-
-      const mockSimple = jest.fn().mockImplementation(async () => ({
-        rawTransaction: null,
-      }));
-      const mockGetLedgerInfo = jest.fn().mockImplementation(async () => ({
-        ledger_timestamp: "0",
-      }));
-      mockedAptos.mockImplementation(() => ({
-        transaction: {
-          build: {
-            simple: mockSimple,
-          },
-        },
-        getLedgerInfo: mockGetLedgerInfo,
-      }));
-
-      const mockSimpleSpy = jest.spyOn({ simple: mockSimple }, "simple");
-
-      const api = new AptosAPI("aptos");
-      await api.generateTransaction("APTOS_1_ADDRESS", payload, options);
-
-      expect(mockSimpleSpy).toHaveBeenCalledWith({
-        data: payload,
-        options: {
-          maxGasAmount: Number(options.maxGasAmount),
-          gasUnitPrice: Number(options.gasUnitPrice),
-          expireTimestamp: 120,
-        },
-        sender: "APTOS_1_ADDRESS",
-      });
-    });
-
-    it("throws an error when failing to build a transaction", async () => {
-      const options = {
-        maxGasAmount: "100",
-        gasUnitPrice: "50",
-      };
-
-      const mockSimple = jest.fn().mockImplementation(async () => null);
-      mockedAptos.mockImplementation(() => ({
-        transaction: {
-          build: {
-            simple: mockSimple,
-          },
-        },
-      }));
-
-      const api = new AptosAPI("aptos");
-      expect(
-        async () => await api.generateTransaction("APTOS_1_ADDRESS", payload, options),
-      ).rejects.toThrow();
-    });
+describe("lastBlock", () => {
+  beforeEach(() => {
+    mockedAptos = jest.mocked(Aptos);
   });
 
-  describe("simulateTransaction", () => {
-    it("simulates a transaction with the correct options", async () => {
-      const mockSimple = jest.fn().mockImplementation(async () => ({
-        rawTransaction: null,
-      }));
-      mockedAptos.mockImplementation(() => ({
-        transaction: {
-          simulate: {
-            simple: mockSimple,
-          },
-        },
-      }));
-
-      const mockSimpleSpy = jest.spyOn({ simple: mockSimple }, "simple");
-
-      const api = new AptosAPI("aptos");
-      const address = new Ed25519PublicKey("APTOS_1_ADDRESS");
-      const tx = new RawTransaction(
-        new AccountAddress(Uint8Array.from(Buffer.from("APTOS_2_ADDRESS"))),
-        BigInt(1),
-        "" as unknown as Serializable,
-        BigInt(100),
-        BigInt(50),
-        BigInt(1),
-        { chainId: 1 } as ChainId,
-      );
-      await api.simulateTransaction(address, tx);
-
-      expect(mockSimpleSpy).toHaveBeenCalledWith({
-        signerPublicKey: address,
-        transaction: { rawTransaction: tx },
-        options: {
-          estimateGasUnitPrice: true,
-          estimateMaxGasAmount: true,
-          estimatePrioritizedGasUnitPrice: false,
-        },
-      });
-    });
+  afterEach(() => {
+    jest.resetAllMocks();
   });
-  describe("broadcast", () => {
-    it("broadcasts the transaction", async () => {
-      mockedPost.mockImplementation(async () => ({ data: { hash: "ok" } }));
-      const mockedPostSpy = jest.spyOn({ post: mockedPost }, "post");
-
-      mockedAptos.mockImplementation(() => ({
-        config: "config",
-      }));
-
-      const api = new AptosAPI("aptos");
-      await api.broadcast("signature");
 
-      expect(mockedPostSpy).toHaveBeenCalledWith({
-        contentType: "application/x.aptos.signed_transaction+bcs",
-        aptosConfig: "config",
-        body: Uint8Array.from(Buffer.from("signature", "hex")),
-        path: "transactions",
-        type: "Fullnode",
-        originMethod: "",
-      });
+  it("returns the last block information", async () => {
+    mockedAptos.mockImplementation(() => ({
+      getLedgerInfo: jest.fn().mockReturnValue({
+        block_height: "123",
+      }),
+      getBlockByHeight: jest.fn().mockReturnValue({
+        block_height: "123",
+        block_hash: "123hash",
+        block_timestamp: "1746021098623892",
+        first_version: "1",
+        last_version: "1",
+      }),
+    }));
+
+    const api: Api<AptosAsset> = createApi(mockAptosConfig);
+
+    expect(await api.lastBlock()).toStrictEqual({
+      height: 123,
+      hash: "123hash",
+      time: new Date(1746021098623892),
     });
   });
 });

package/src/__tests__/bridge/broadcast.test.ts

@@ -1,10 +1,10 @@
 import broadcast from "../../bridge/broadcast";
-import { AptosAPI } from "../../api";
+import { AptosAPI } from "../../network";
 import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
 import type { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 
-jest.mock("../../api");
+jest.mock("../../network");
 jest.mock("@ledgerhq/coin-framework/operation");
 
 describe("broadcast", () => {

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

@@ -1,6 +1,11 @@
-import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import {
+  createFixtureAccount,
+  createFixtureAccountWithSubAccount,
+  createFixtureTransaction,
+  createFixtureTransactionWithSubAccount,
+} from "../../bridge/bridge.fixture";
 import buildTransaction from "../../bridge/buildTransaction";
-import { AptosAPI } from "../../api";
+import { AptosAPI } from "../../network";
 import { normalizeTransactionOptions } from "../../bridge/logic";
 import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
 import { TransactionOptions } from "../../types";
@@ -16,7 +21,7 @@ jest.mock("../../bridge/logic", () => ({
   DEFAULT_GAS_PRICE: 200,
 }));
 
-jest.mock("../../api", () => {
+jest.mock("../../network", () => {
   return {
     AptosAPI: function () {
       return {
@@ -26,8 +31,12 @@ jest.mock("../../api", () => {
   };
 });
 
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
 describe("buildTransaction Test", () => {
-  it("should return tx", async () => {
+  it("should return transaction for main account", async () => {
     const account = createFixtureAccount();
     const transaction = createFixtureTransaction();
     const aptosClient = new AptosAPI(account.currency.id);
@@ -54,8 +63,81 @@ describe("buildTransaction Test", () => {
     expect(generateTransactionArgs[1]).toEqual({
       function: "0x1::aptos_account::transfer_coins",
       typeArguments: ["0x1::aptos_coin::AptosCoin"],
-      functionArguments: ["", "0"],
+      functionArguments: ["recipient", "0"],
+    });
+    expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
+  });
+
+  it("should return transaction for token account of type fungible asset", async () => {
+    const account = createFixtureAccountWithSubAccount("fungible_asset");
+    const transaction = createFixtureTransactionWithSubAccount();
+    const aptosClient = new AptosAPI(account.currency.id);
+    const result = await buildTransaction(account, transaction, aptosClient);
+
+    const expected = "tx";
+
+    expect(result).toBe(expected);
+
+    const mockedNormalizeTransactionOptions = jest.mocked(normalizeTransactionOptions);
+
+    expect(mockedNormalizeTransactionOptions).toHaveBeenCalledTimes(1);
+    expect(generateTransaction).toHaveBeenCalledTimes(1);
+
+    const generateTransactionArgs: [string, InputEntryFunctionData, TransactionOptions][] =
+      generateTransaction.mock.calls[0];
+
+    expect(mockedNormalizeTransactionOptions.mock.calls[0][0]).toEqual({
+      maxGasAmount: "0",
+      gasUnitPrice: "0",
+    });
+
+    expect(generateTransactionArgs[0]).toBe("address");
+    expect(generateTransactionArgs[1]).toEqual({
+      function: "0x1::primary_fungible_store::transfer",
+      typeArguments: ["0x1::fungible_asset::Metadata"],
+      functionArguments: ["contract_address", "recipient", "0"],
+    });
+    expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
+  });
+
+  it("should return transaction for token account of type coin", async () => {
+    const account = createFixtureAccountWithSubAccount("coin");
+    const transaction = createFixtureTransactionWithSubAccount();
+    const aptosClient = new AptosAPI(account.currency.id);
+    const result = await buildTransaction(account, transaction, aptosClient);
+
+    const expected = "tx";
+
+    expect(result).toBe(expected);
+
+    const mockedNormalizeTransactionOptions = jest.mocked(normalizeTransactionOptions);
+
+    expect(mockedNormalizeTransactionOptions).toHaveBeenCalledTimes(1);
+    expect(generateTransaction).toHaveBeenCalledTimes(1);
+
+    const generateTransactionArgs: [string, InputEntryFunctionData, TransactionOptions][] =
+      generateTransaction.mock.calls[0];
+
+    expect(mockedNormalizeTransactionOptions.mock.calls[0][0]).toEqual({
+      maxGasAmount: "0",
+      gasUnitPrice: "0",
+    });
+
+    expect(generateTransactionArgs[0]).toBe("address");
+    expect(generateTransactionArgs[1]).toEqual({
+      function: "0x1::aptos_account::transfer_coins",
+      typeArguments: ["contract_address"],
+      functionArguments: ["recipient", "0"],
     });
     expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
   });
+
+  it("should throw error if token is not supported", async () => {
+    const account = createFixtureAccountWithSubAccount("not_supported_token_type");
+    const transaction = createFixtureTransactionWithSubAccount();
+    const aptosClient = new AptosAPI(account.currency.id);
+    expect(async () => await buildTransaction(account, transaction, aptosClient)).rejects.toThrow(
+      "Token type not_supported_token_type not supported",
+    );
+  });
 });