@ledgerhq/coin-aptos 1.4.0-next.0

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

@@ -0,0 +1,499 @@
+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";
+
+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);
+
+describe("Aptos API", () => {
+  beforeEach(() => {
+    mockedAptos = jest.mocked(Aptos);
+    mockedApolloClient = jest.mocked(ApolloClient);
+    mockedPost = jest.mocked(post);
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  it("builds the client properly for mainnet", () => {
+    const api = new AptosAPI("aptos");
+
+    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");
+  });
+
+  it("builds the client properly for testnet", () => {
+    const api = new AptosAPI("aptos_testnet");
+
+    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");
+  });
+
+  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");
+
+      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);
+    });
+  });
+
+  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("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,
+        },
+      });
+    });
+  });
+  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: "",
+      });
+    });
+  });
+});

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

@@ -0,0 +1,98 @@
+import broadcast from "../../bridge/broadcast";
+import { AptosAPI } from "../../api";
+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("@ledgerhq/coin-framework/operation");
+
+describe("broadcast", () => {
+  const mockAccount: Account = {
+    type: "Account",
+    seedIdentifier: "mockSeedIdentifier",
+    operationsCount: 0,
+    id: "mockAccountId",
+    currency: {
+      type: "CryptoCurrency",
+      id: "aptos",
+      name: "Aptos",
+      ticker: "APT",
+      units: [{ name: "APT", code: "APT", magnitude: 6 }],
+      managerAppName: "Aptos",
+      coinType: 637,
+      scheme: "aptos",
+      color: "#000000",
+      family: "aptos",
+      blockAvgTime: 5,
+      explorerViews: [],
+    },
+    balance: BigNumber(1000),
+    spendableBalance: BigNumber(1000),
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    blockHeight: 0,
+    index: 0,
+    derivationMode: "",
+    freshAddress: "",
+    freshAddressPath: "",
+    used: false,
+    swapHistory: [],
+    creationDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: { latestDate: 0, balances: [] },
+      DAY: { latestDate: 0, balances: [] },
+      WEEK: { latestDate: 0, balances: [] },
+    },
+  };
+
+  const mockOperation: Operation = {
+    id: "mockOperationId",
+    hash: "",
+    type: "OUT",
+    value: BigNumber(100),
+    fee: BigNumber(1),
+    senders: ["sender"],
+    recipients: ["recipient"],
+    blockHeight: null,
+    blockHash: null,
+    accountId: "mockAccountId",
+    date: new Date(),
+    extra: {},
+  };
+
+  const mockSignedOperation: SignedOperation = {
+    operation: mockOperation,
+    signature: "mockSignature",
+  };
+
+  it("should broadcast the signed operation and return the patched operation", async () => {
+    const mockHash = "mockHash";
+    (AptosAPI.prototype.broadcast as jest.Mock).mockResolvedValue(mockHash);
+    (patchOperationWithHash as jest.Mock).mockReturnValue({
+      ...mockOperation,
+      hash: mockHash,
+    });
+
+    const result = await broadcast({
+      signedOperation: mockSignedOperation,
+      account: mockAccount,
+    });
+
+    expect(AptosAPI.prototype.broadcast).toHaveBeenCalledWith("mockSignature");
+    expect(patchOperationWithHash).toHaveBeenCalledWith(mockOperation, mockHash);
+    expect(result).toEqual({ ...mockOperation, hash: mockHash });
+  });
+
+  it("should throw an error if broadcast fails", async () => {
+    (AptosAPI.prototype.broadcast as jest.Mock).mockRejectedValue(new Error("Broadcast failed"));
+
+    await expect(
+      broadcast({
+        signedOperation: mockSignedOperation,
+        account: mockAccount,
+      }),
+    ).rejects.toThrow("Broadcast failed");
+  });
+});

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

@@ -0,0 +1,61 @@
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import buildTransaction from "../../bridge/buildTransaction";
+import { AptosAPI } from "../../api";
+import { normalizeTransactionOptions } from "../../bridge/logic";
+import { InputEntryFunctionData } from "@aptos-labs/ts-sdk";
+import { TransactionOptions } from "../../types";
+
+const generateTransaction = jest.fn(() => "tx");
+
+jest.mock("../../bridge/logic", () => ({
+  normalizeTransactionOptions: jest.fn(() => ({
+    maxGasAmount: "100",
+    gasUnitPrice: "200",
+  })),
+  DEFAULT_GAS: 100,
+  DEFAULT_GAS_PRICE: 200,
+}));
+
+jest.mock("../../api", () => {
+  return {
+    AptosAPI: function () {
+      return {
+        generateTransaction,
+      };
+    },
+  };
+});
+
+describe("buildTransaction Test", () => {
+  it("should return tx", async () => {
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+    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: ["0x1::aptos_coin::AptosCoin"],
+      functionArguments: ["", "0"],
+    });
+    expect(generateTransactionArgs[2]).toEqual({ maxGasAmount: "100", gasUnitPrice: "200" });
+  });
+});

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

@@ -0,0 +1,27 @@
+import BigNumber from "bignumber.js";
+import createTransaction from "../../bridge/createTransaction";
+
+jest.mock("../../bridge/logic", () => ({
+  DEFAULT_GAS: 100,
+  DEFAULT_GAS_PRICE: 200,
+}));
+
+describe("createTransaction Test", () => {
+  it("should return a transaction object", async () => {
+    const result = createTransaction();
+
+    const expected = {
+      family: "aptos",
+      mode: "send",
+      amount: BigNumber(0),
+      recipient: "",
+      useAllAmount: false,
+      options: {
+        maxGasAmount: "100",
+        gasUnitPrice: "200",
+      },
+    };
+
+    expect(result).toEqual(expected);
+  });
+});

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

@@ -0,0 +1,19 @@
+import getDeviceTransactionConfig, { methodToString } from "../../bridge/deviceTransactionConfig";
+
+describe("deviceTransactionConfig", () => {
+  test("methodToString", () => {
+    expect(methodToString(0)).toBe("Coin transfer");
+    expect(methodToString(1)).toBe("Unknown");
+  });
+
+  test("getDeviceTransactionConfig", () => {
+    const fields = getDeviceTransactionConfig();
+    expect(fields).toMatchObject([
+      {
+        type: "text",
+        label: "Type",
+        value: "Coin transfer",
+      },
+    ]);
+  });
+});