@ledgerhq/coin-aptos 1.4.0-next.0

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

@@ -0,0 +1,118 @@
+import prepareTransaction from "../../bridge/prepareTransaction";
+import { AptosAPI } from "../../api";
+import { getEstimatedGas } from "../../bridge/getFeesForTransaction";
+import { getMaxSendBalance } from "../../bridge/logic";
+import BigNumber from "bignumber.js";
+import type { Account } from "@ledgerhq/types-live";
+import type { Transaction } from "../../types";
+
+jest.mock("../../api");
+jest.mock("../../bridge/getFeesForTransaction");
+jest.mock("../../bridge/logic");
+
+describe("Aptos prepareTransaction", () => {
+  describe("prepareTransaction", () => {
+    let account: Account;
+    let transaction: Transaction;
+
+    beforeEach(() => {
+      account = {
+        id: "test-account-id",
+        name: "Test Account",
+        currency: {
+          id: "aptos",
+          name: "Aptos",
+          ticker: "APT",
+          units: [{ name: "Aptos", code: "APT", magnitude: 6 }],
+        },
+        spendableBalance: new BigNumber(1000),
+        balance: new BigNumber(1000),
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        unit: { code: "APT", name: "Aptos", magnitude: 6 },
+        lastSyncDate: new Date(),
+        subAccounts: [],
+      } as unknown as Account;
+
+      transaction = {
+        amount: new BigNumber(0),
+        recipient: "",
+        useAllAmount: false,
+        fees: new BigNumber(0),
+      } as Transaction;
+    });
+
+    it("should return the transaction if recipient is not set", async () => {
+      const result = await prepareTransaction(account, transaction);
+      expect(result).toEqual(transaction);
+    });
+
+    it("should return the transaction with zero fees if amount is zero and useAllAmount is false", async () => {
+      transaction.recipient = "test-recipient";
+      const result = await prepareTransaction(account, transaction);
+      expect(result.fees?.isZero()).toBe(true);
+    });
+
+    it("should set the amount to max sendable balance if useAllAmount is true", async () => {
+      transaction.recipient = "test-recipient";
+      transaction.useAllAmount = true;
+      (getMaxSendBalance as jest.Mock).mockReturnValue(new BigNumber(900));
+      (getEstimatedGas as jest.Mock).mockResolvedValue({
+        fees: new BigNumber(2000),
+        estimate: { maxGasAmount: new BigNumber(200), gasUnitPrice: new BigNumber(10) },
+        errors: {},
+      });
+
+      const result = await prepareTransaction(account, transaction);
+      expect(result.amount.isEqualTo(new BigNumber(900))).toBe(true);
+      expect(result.fees?.isEqualTo(new BigNumber(2000))).toBe(true);
+      expect(new BigNumber(result.options.maxGasAmount).isEqualTo(new BigNumber(200))).toBe(true);
+      expect(result.errors).toEqual({});
+    });
+
+    it("should call getEstimatedGas and set the transaction fees, estimate, and errors", async () => {
+      transaction.recipient = "test-recipient";
+      transaction.amount = new BigNumber(100);
+      (getEstimatedGas as jest.Mock).mockResolvedValue({
+        fees: new BigNumber(10),
+        estimate: { maxGasAmount: new BigNumber(200) },
+        errors: {},
+      });
+
+      const result = await prepareTransaction(account, transaction);
+      expect(getEstimatedGas).toHaveBeenCalledWith(account, transaction, expect.any(AptosAPI));
+      expect(result.fees?.isEqualTo(new BigNumber(10))).toBe(true);
+      expect(new BigNumber(result.options.maxGasAmount).isEqualTo(new BigNumber(200))).toBe(true);
+      expect(result.errors).toEqual({});
+    });
+
+    it("should return the transaction with updated fees and estimate if recipient is set and amount is not zero", async () => {
+      transaction.recipient = "test-recipient";
+      transaction.amount = new BigNumber(100);
+      (getEstimatedGas as jest.Mock).mockResolvedValue({
+        fees: new BigNumber(2000),
+        estimate: { maxGasAmount: new BigNumber(200), gasUnitPrice: new BigNumber(10) },
+        errors: {},
+      });
+
+      const result = await prepareTransaction(account, transaction);
+      expect(result.fees?.isEqualTo(new BigNumber(2000))).toBe(true);
+      expect(new BigNumber(result.options.maxGasAmount).isEqualTo(new BigNumber(200))).toBe(true);
+      expect(result.errors).toEqual({});
+    });
+
+    it("should set maxGasAmount in options", async () => {
+      transaction.recipient = "test-recipient";
+      transaction.amount = new BigNumber(100);
+      (getEstimatedGas as jest.Mock).mockResolvedValue({
+        fees: new BigNumber(2000),
+        estimate: { maxGasAmount: new BigNumber(200), gasUnitPrice: new BigNumber(10) },
+        errors: {},
+      });
+
+      const result = await prepareTransaction(account, transaction);
+      expect(new BigNumber(result.options.maxGasAmount).isEqualTo(new BigNumber(200))).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,178 @@
+import BigNumber from "bignumber.js";
+import { Observable } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/lib/signer";
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import buildSignOperation, { getAddress } from "../../bridge/signOperation";
+import { AptosSigner } from "../../types";
+import { signTransaction } from "../../network";
+
+jest.mock("../../api", () => {
+  return {
+    AptosAPI: function () {
+      return {
+        generateTransaction: jest.fn(() => "tx"),
+      };
+    },
+  };
+});
+
+jest.mock("../../bridge/buildTransaction", () => {
+  return function () {
+    return {
+      sequence_number: "789",
+    };
+  };
+});
+
+jest.mock("../../network");
+let mockedSignTransaction: jest.Mocked<any>;
+
+describe("getAddress", () => {
+  it("should return address and derivationPath", () => {
+    const account = createFixtureAccount();
+    expect(getAddress(account)).toEqual({ address: "address", derivationPath: "derivation_path" });
+  });
+});
+
+describe("buildSignOperation", () => {
+  beforeEach(() => {
+    mockedSignTransaction = jest.mocked(signTransaction);
+  });
+  afterEach(() => jest.clearAllMocks());
+
+  it("should thrown an error", async () => {
+    mockedSignTransaction.mockImplementation(() => {
+      throw new Error("observable-catch-error");
+    });
+
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    account.id = "js:2:aptos:0x000:";
+    transaction.mode = "send";
+
+    const observable = await buildSignOperation({} as unknown as SignerContext<AptosSigner>)({
+      account,
+      deviceId: "1",
+      transaction,
+    });
+
+    observable.subscribe({
+      error: err => {
+        expect(err.message).toBe("observable-catch-error");
+      },
+    });
+  });
+
+  it("should return 3 operations", async () => {
+    mockedSignTransaction.mockReturnValue("signedTx");
+
+    const date = new Date("2020-01-01");
+    jest.useFakeTimers().setSystemTime(date);
+
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    account.id = "js:2:aptos:0x000:";
+    transaction.mode = "send";
+
+    const observable = await buildSignOperation({} as unknown as SignerContext<AptosSigner>)({
+      account,
+      deviceId: "1",
+      transaction,
+    });
+
+    expect(observable).toBeInstanceOf(Observable);
+
+    const expectedValues = [
+      { type: "device-signature-requested" },
+      { type: "device-signature-granted" },
+      {
+        type: "signed",
+        signedOperation: {
+          operation: {
+            id: "js:2:aptos:0x000:--OUT",
+            hash: "",
+            type: "OUT",
+            value: new BigNumber(0),
+            fee: new BigNumber(0),
+            extra: {},
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient],
+            accountId: "js:2:aptos:0x000:",
+            date,
+            transactionSequenceNumber: 789,
+          },
+          signature: "7369676e65645478",
+        },
+      },
+    ];
+
+    let i = 0;
+
+    observable.forEach(signOperationEvent => {
+      expect(signOperationEvent).toEqual(expectedValues[i]);
+      i++;
+    });
+  });
+
+  it("should return 3 operations with all amount", async () => {
+    mockedSignTransaction.mockReturnValue("signedTx");
+
+    const date = new Date("2020-01-01");
+    jest.useFakeTimers().setSystemTime(date);
+
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    account.balance = new BigNumber(40);
+    transaction.fees = new BigNumber(30);
+    transaction.useAllAmount = true;
+
+    account.id = "js:2:aptos:0x000:";
+    transaction.mode = "send";
+
+    const observable = await buildSignOperation({} as unknown as SignerContext<AptosSigner>)({
+      account,
+      deviceId: "1",
+      transaction,
+    });
+
+    expect(observable).toBeInstanceOf(Observable);
+
+    const expectedValues = [
+      { type: "device-signature-requested" },
+      { type: "device-signature-granted" },
+      {
+        type: "signed",
+        signedOperation: {
+          operation: {
+            id: "js:2:aptos:0x000:--OUT",
+            hash: "",
+            type: "OUT",
+            value: new BigNumber(10),
+            fee: transaction.fees,
+            extra: {},
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient],
+            accountId: "js:2:aptos:0x000:",
+            date,
+            transactionSequenceNumber: 789,
+          },
+          signature: "7369676e65645478",
+        },
+      },
+    ];
+
+    let i = 0;
+
+    observable.forEach(signOperationEvent => {
+      expect(signOperationEvent).toEqual(expectedValues[i]);
+      i++;
+    });
+  });
+});

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

@@ -0,0 +1,374 @@
+import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { Account, SyncConfig } from "@ledgerhq/types-live";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { AptosAPI } from "../../api";
+import { getAccountShape } from "../../bridge/synchronisation";
+
+jest.mock("@ledgerhq/coin-framework/account", () => {
+  const originalModule = jest.requireActual("@ledgerhq/coin-framework/account");
+  const partialMockedModule = Object.keys(originalModule).reduce(
+    (pre: { [key: string]: jest.Mock }, methodName) => {
+      pre[methodName] = jest.fn();
+      return pre;
+    },
+    {} as { [key: string]: jest.Mock },
+  );
+  return {
+    ...partialMockedModule,
+    // mock all except these
+    decodeAccountId: originalModule.decodeAccountId,
+  };
+});
+
+const mockedEncodeAccountId = jest.mocked(encodeAccountId);
+
+jest.mock("../../api");
+let mockedAptosAPI: jest.Mocked<any>;
+
+jest.mock("@ledgerhq/coin-framework/bridge/jsHelpers");
+jest.mock("invariant", () => jest.fn());
+
+describe("getAccountShape", () => {
+  beforeEach(() => {
+    mockedAptosAPI = jest.mocked(AptosAPI);
+    jest.mocked(mergeOps).mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("account with xpub", async () => {
+    const mockGetAccountInfo = jest.fn().mockImplementation(async () => ({
+      balance: BigInt(0),
+      transactions: [],
+      blockHeight: 0,
+    }));
+    mockedAptosAPI.mockImplementation(() => ({
+      getAccountInfo: mockGetAccountInfo,
+    }));
+    const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
+
+    const account = await getAccountShape(
+      {
+        id: "1",
+        address: "address",
+        currency: getCryptoCurrencyById("aptos"),
+        derivationMode: "",
+        index: 0,
+        xpub: "address",
+        derivationPath: "",
+        deviceId: "1",
+        initialAccount: {
+          id: "1:1:1:1:1",
+          xpub: "address",
+          seedIdentifier: "1",
+          derivationMode: "",
+          index: 0,
+          freshAddress: "address",
+          freshAddressPath: "",
+          used: true,
+          balance: BigInt(10),
+          spendableBalance: BigInt(10),
+          creationDate: new Date(),
+          blockHeight: 0,
+          currency: getCryptoCurrencyById("aptos"),
+          operationsCount: 0,
+          operations: [],
+          pendingOperations: [],
+          lastSyncDate: new Date(),
+          balanceHistoryCache: {},
+          swapHistory: [],
+        },
+      } as unknown as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    expect(account.xpub).toEqual("address");
+    expect(mockedEncodeAccountId).toHaveBeenCalledTimes(1);
+    expect(mockedAptosAPI).toHaveBeenCalledTimes(1);
+    expect(mockGetAccountSpy).toHaveBeenCalledWith("address", undefined);
+  });
+
+  it("account without xpub", async () => {
+    const mockGetAccountInfo = jest.fn().mockImplementation(async () => ({
+      balance: BigInt(0),
+      transactions: [],
+      blockHeight: 0,
+    }));
+    mockedAptosAPI.mockImplementation(() => ({
+      getAccountInfo: mockGetAccountInfo,
+    }));
+    const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
+
+    const account = await getAccountShape(
+      {
+        id: "1",
+        address: "address",
+        currency: getCryptoCurrencyById("aptos"),
+        derivationMode: "",
+        index: 0,
+        xpub: "address",
+        derivationPath: "",
+        deviceId: "1",
+        initialAccount: {
+          id: "1:1:1:1:1",
+          seedIdentifier: "1",
+          derivationMode: "",
+          index: 0,
+          freshAddress: "address",
+          freshAddressPath: "",
+          used: true,
+          balance: BigInt(10),
+          spendableBalance: BigInt(10),
+          creationDate: new Date(),
+          blockHeight: 0,
+          currency: getCryptoCurrencyById("aptos"),
+          operationsCount: 0,
+          operations: [],
+          pendingOperations: [],
+          lastSyncDate: new Date(),
+          balanceHistoryCache: {},
+          swapHistory: [],
+        },
+      } as unknown as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    expect(account.xpub).toEqual("1");
+    expect(mockedEncodeAccountId).toHaveBeenCalledTimes(1);
+    expect(mockedAptosAPI).toHaveBeenCalledTimes(1);
+    expect(mockGetAccountSpy).toHaveBeenCalledWith("address", undefined);
+  });
+
+  it("without initialAccount", async () => {
+    const mockGetAccountInfo = jest.fn().mockImplementation(async () => ({
+      balance: BigInt(0),
+      transactions: [],
+      blockHeight: 0,
+    }));
+    mockedAptosAPI.mockImplementation(() => ({
+      getAccountInfo: mockGetAccountInfo,
+    }));
+    const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
+
+    const account = await getAccountShape(
+      {
+        id: "1",
+        address: "address",
+        currency: getCryptoCurrencyById("aptos"),
+        derivationMode: "",
+        index: 0,
+        xpub: "address",
+        derivationPath: "",
+        deviceId: "1",
+      } as unknown as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    expect(account.xpub).toEqual("");
+    expect(mockedEncodeAccountId).toHaveBeenCalledTimes(1);
+    expect(mockedAptosAPI).toHaveBeenCalledTimes(1);
+    expect(mockGetAccountSpy).toHaveBeenCalledWith("address", undefined);
+  });
+
+  it("initialAccount with operations", async () => {
+    const mockGetAccountInfo = jest.fn().mockImplementation(async () => ({
+      balance: BigInt(0),
+      transactions: [],
+      blockHeight: 0,
+    }));
+    mockedAptosAPI.mockImplementation(() => ({
+      getAccountInfo: mockGetAccountInfo,
+    }));
+    const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
+
+    const account = await getAccountShape(
+      {
+        id: "1",
+        address: "address",
+        currency: getCryptoCurrencyById("aptos"),
+        derivationMode: "",
+        index: 0,
+        xpub: "address",
+        derivationPath: "",
+        deviceId: "1",
+        initialAccount: {
+          id: "1:1:1:1:1",
+          seedIdentifier: "1",
+          derivationMode: "",
+          index: 0,
+          freshAddress: "address",
+          freshAddressPath: "",
+          used: true,
+          balance: BigInt(10),
+          spendableBalance: BigInt(10),
+          creationDate: new Date(),
+          blockHeight: 0,
+          currency: getCryptoCurrencyById("aptos"),
+          t: 1,
+          operations: [
+            {
+              id: "1",
+              hash: "hash",
+              type: "OUT",
+              value: BigInt(10),
+              fee: BigInt(0),
+              blockHeight: 0,
+              blockHash: "blockHash",
+              accountId: "1",
+              senders: ["sender"],
+              recipients: ["recipient"],
+              date: new Date(),
+            },
+          ],
+          pendingOperations: [],
+          lastSyncDate: new Date(),
+          balanceHistoryCache: {},
+          swapHistory: [],
+        },
+      } as unknown as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    expect(account.xpub).toEqual("1");
+    expect(mockedEncodeAccountId).toHaveBeenCalledTimes(1);
+    expect(mockedAptosAPI).toHaveBeenCalledTimes(1);
+    expect(mockGetAccountSpy).toHaveBeenCalledWith("address", undefined);
+  });
+
+  it("initialAccount with operations with extra", async () => {
+    const mockGetAccountInfo = jest.fn().mockImplementation(async () => ({
+      balance: BigInt(0),
+      transactions: [],
+      blockHeight: 0,
+    }));
+    mockedAptosAPI.mockImplementation(() => ({
+      getAccountInfo: mockGetAccountInfo,
+    }));
+    const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
+
+    const account = await getAccountShape(
+      {
+        id: "1",
+        address: "address",
+        currency: getCryptoCurrencyById("aptos"),
+        derivationMode: "",
+        index: 0,
+        xpub: "address",
+        derivationPath: "",
+        deviceId: "1",
+        initialAccount: {
+          id: "1:1:1:1:1",
+          seedIdentifier: "1",
+          derivationMode: "",
+          index: 0,
+          freshAddress: "address",
+          freshAddressPath: "",
+          used: true,
+          balance: BigInt(10),
+          spendableBalance: BigInt(10),
+          creationDate: new Date(),
+          blockHeight: 0,
+          currency: getCryptoCurrencyById("aptos"),
+          t: 1,
+          operations: [
+            {
+              id: "1",
+              hash: "hash",
+              type: "OUT",
+              value: BigInt(10),
+              fee: BigInt(0),
+              blockHeight: 0,
+              blockHash: "blockHash",
+              accountId: "1",
+              senders: ["sender"],
+              recipients: ["recipient"],
+              date: new Date(),
+              extra: { version: 1 },
+            },
+          ],
+          pendingOperations: [],
+          lastSyncDate: new Date(),
+          balanceHistoryCache: {},
+          swapHistory: [],
+        },
+      } as unknown as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    expect(account.xpub).toEqual("1");
+    expect(mockedEncodeAccountId).toHaveBeenCalledTimes(1);
+    expect(mockedAptosAPI).toHaveBeenCalledTimes(1);
+    expect(mockGetAccountSpy).toHaveBeenCalledWith("address", 1);
+  });
+
+  it("get publicKey from rest", async () => {
+    const mockGetAccountInfo = jest.fn().mockImplementation(async () => ({
+      balance: BigInt(0),
+      transactions: [],
+      blockHeight: 0,
+    }));
+    mockedAptosAPI.mockImplementation(() => ({
+      getAccountInfo: mockGetAccountInfo,
+    }));
+    const mockGetAccountSpy = jest.spyOn({ getAccount: mockGetAccountInfo }, "getAccount");
+
+    const account = await getAccountShape(
+      {
+        id: "1",
+        address: "address",
+        currency: getCryptoCurrencyById("aptos"),
+        derivationMode: "",
+        index: 0,
+        xpub: "address",
+        derivationPath: "",
+        deviceId: "1",
+        initialAccount: {
+          id: "1:1:1:1:1",
+          seedIdentifier: "1",
+          derivationMode: "",
+          index: 0,
+          freshAddress: "address",
+          freshAddressPath: "",
+          used: true,
+          balance: BigInt(10),
+          spendableBalance: BigInt(10),
+          creationDate: new Date(),
+          blockHeight: 0,
+          currency: getCryptoCurrencyById("aptos"),
+          t: 1,
+          operations: [
+            {
+              id: "1",
+              hash: "hash",
+              type: "OUT",
+              value: BigInt(10),
+              fee: BigInt(0),
+              blockHeight: 0,
+              blockHash: "blockHash",
+              accountId: "1",
+              senders: ["sender"],
+              recipients: ["recipient"],
+              date: new Date(),
+              extra: { version: 1 },
+            },
+          ],
+          pendingOperations: [],
+          lastSyncDate: new Date(),
+          balanceHistoryCache: {},
+          swapHistory: [],
+        },
+        rest: { publicKey: "restPublicKey" },
+      } as unknown as AccountShapeInfo<Account>,
+      {} as SyncConfig,
+    );
+
+    expect(account.xpub).toEqual("restPublicKey");
+    expect(mockedEncodeAccountId).toHaveBeenCalledTimes(1);
+    expect(mockedAptosAPI).toHaveBeenCalledTimes(1);
+    expect(mockGetAccountSpy).toHaveBeenCalledWith("address", 1);
+  });
+});