@ledgerhq/coin-aptos 1.4.0-next.0

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

@@ -0,0 +1,94 @@
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import estimateMaxSpendable from "../../bridge/estimateMaxSpendable";
+import BigNumber from "bignumber.js";
+
+jest.mock("../../bridge/getFeesForTransaction", () => ({
+  getEstimatedGas: jest.fn(() => ({
+    fees: new BigNumber(0),
+    estimate: {
+      maxGasAmount: 1,
+      gasUnitPrice: 2,
+    },
+    errors: {},
+  })),
+}));
+
+describe("estimateMaxSpendable Test", () => {
+  describe("spendable balance is lower than the total gas", () => {
+    it("should return 0", async () => {
+      const account = createFixtureAccount();
+
+      const spendableBalance = new BigNumber(0);
+
+      account.spendableBalance = spendableBalance;
+
+      const result = await estimateMaxSpendable({
+        account,
+      });
+
+      const expected = spendableBalance;
+
+      expect(result.isEqualTo(expected)).toBe(true);
+    });
+  });
+
+  describe("spendable balance is higher than the total gas", () => {
+    it("should return spendable amount minus total gas", async () => {
+      const account = createFixtureAccount();
+
+      const spendableBalance = new BigNumber(100000);
+
+      account.spendableBalance = spendableBalance;
+
+      const result = await estimateMaxSpendable({
+        account,
+      });
+
+      const expected = new BigNumber(80000);
+
+      expect(result.isEqualTo(expected)).toBe(true);
+    });
+  });
+
+  describe("transaction spendable balance is higher than the total gas", () => {
+    it("should return transaction spendable amount minus total gas", async () => {
+      const account = createFixtureAccount();
+      const transaction = createFixtureTransaction();
+
+      const spendableBalance = new BigNumber(1);
+
+      account.spendableBalance = spendableBalance;
+
+      const result = await estimateMaxSpendable({
+        account,
+        parentAccount: account,
+        transaction,
+      });
+
+      const expected = new BigNumber(0);
+
+      expect(result.isEqualTo(expected)).toBe(true);
+    });
+  });
+
+  describe("transaction spendable balance is higher than the total gas", () => {
+    it("should return transaction spendable amount minus total gas", async () => {
+      const account = createFixtureAccount();
+      const transaction = createFixtureTransaction();
+
+      const spendableBalance = new BigNumber(100000);
+
+      account.spendableBalance = spendableBalance;
+
+      const result = await estimateMaxSpendable({
+        account,
+        parentAccount: account,
+        transaction,
+      });
+
+      const expected = new BigNumber(99998);
+
+      expect(result.isEqualTo(expected)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,189 @@
+import BigNumber from "bignumber.js";
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import * as getFeesForTransaction from "../../bridge/getFeesForTransaction";
+import { AptosAPI } from "../../api";
+
+let simulateTransaction = jest.fn();
+
+jest.mock("../../api", () => {
+  return {
+    AptosAPI: function () {
+      return {
+        estimateGasPrice: jest.fn(() => ({ gas_estimate: 101 })),
+        generateTransaction: jest.fn(() => "tx"),
+        simulateTransaction,
+        getAccount: jest.fn(() => ({ sequence_number: "123" })),
+      };
+    },
+  };
+});
+
+jest.mock("@aptos-labs/ts-sdk", () => {
+  return {
+    Ed25519PublicKey: jest.fn(),
+  };
+});
+
+jest.mock("../../bridge/logic", () => {
+  return {
+    DEFAULT_GAS: 201,
+    DEFAULT_GAS_PRICE: 101,
+    ESTIMATE_GAS_MUL: 1,
+    normalizeTransactionOptions: jest.fn(),
+  };
+});
+
+describe("getFeesForTransaction Test", () => {
+  describe("when using getFee", () => {
+    describe("with vm_status as INSUFFICIENT_BALANCE", () => {
+      it("should return a fee estimation object", async () => {
+        simulateTransaction = jest.fn(() => [
+          {
+            success: false,
+            vm_status: ["INSUFFICIENT_BALANCE"],
+            expiration_timestamp_secs: 5,
+            gas_used: "202",
+            gas_unit_price: "102",
+          },
+        ]);
+
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+        const aptosClient = new AptosAPI(account.currency.id);
+
+        transaction.amount = new BigNumber(1);
+        account.xpub = "xpub";
+        account.spendableBalance = new BigNumber(100000000);
+
+        const result = await getFeesForTransaction.getFee(account, transaction, aptosClient);
+
+        const expected = {
+          fees: new BigNumber(20604),
+          estimate: {
+            maxGasAmount: "202",
+            gasUnitPrice: "102",
+          },
+          errors: {},
+        };
+
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe("with vm_status as DUMMY_STATE", () => {
+      it("should return a fee estimation object", () => {
+        simulateTransaction = jest.fn(() => [
+          {
+            success: false,
+            vm_status: ["DUMMY_STATE"],
+            expiration_timestamp_secs: 5,
+            gas_used: "9",
+            gas_unit_price: "100",
+          },
+        ]);
+
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+        const aptosClient = new AptosAPI(account.currency.id);
+
+        transaction.amount = new BigNumber(1);
+        account.xpub = "xpub";
+        account.spendableBalance = new BigNumber(100000000);
+
+        expect(async () => {
+          await getFeesForTransaction.getFee(account, transaction, aptosClient);
+        }).rejects.toThrow("Simulation failed with following error: DUMMY_STATE");
+      });
+    });
+  });
+
+  describe("when using getEstimatedGas", () => {
+    describe("when key not in cache", () => {
+      it("should return fee", async () => {
+        simulateTransaction = jest.fn(() => [
+          {
+            success: true,
+            vm_status: [],
+            expiration_timestamp_secs: 5,
+            gas_used: "9",
+            gas_unit_price: "102",
+          },
+        ]);
+
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+        const aptosClient = new AptosAPI(account.currency.id);
+
+        transaction.amount = new BigNumber(1);
+        account.xpub = "xpub";
+        account.spendableBalance = new BigNumber(100000000);
+
+        const result = await getFeesForTransaction.getEstimatedGas(
+          account,
+          transaction,
+          aptosClient,
+        );
+
+        const expected = {
+          errors: {},
+          estimate: {
+            gasUnitPrice: "102",
+            maxGasAmount: "9",
+          },
+          fees: new BigNumber("918"),
+        };
+
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe("when key is in cache", () => {
+      beforeEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should return cached fee", async () => {
+        simulateTransaction = jest.fn(() => [
+          {
+            success: true,
+            vm_status: [],
+            expiration_timestamp_secs: 5,
+            gas_used: "202",
+            gas_unit_price: "102",
+          },
+        ]);
+        const account = createFixtureAccount();
+        account.xpub = "xpub";
+        const transaction = createFixtureTransaction();
+        const aptosClient = new AptosAPI(account.currency.id);
+
+        transaction.amount = new BigNumber(10);
+
+        const result1 = await getFeesForTransaction.getEstimatedGas(
+          account,
+          transaction,
+          aptosClient,
+        );
+        const result2 = await getFeesForTransaction.getEstimatedGas(
+          account,
+          transaction,
+          aptosClient,
+        );
+
+        expect(simulateTransaction.mock.calls).toHaveLength(1);
+
+        const expected = {
+          errors: {},
+          estimate: {
+            gasUnitPrice: "102",
+            maxGasAmount: "202",
+          },
+          fees: new BigNumber("20604"),
+        };
+
+        expect(result1).toEqual(expected);
+        expect(result2).toEqual(expected);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,155 @@
+import BigNumber from "bignumber.js";
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import getTransactionStatus from "../../bridge/getTransactionStatus";
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+
+describe("getTransactionStatus Test", () => {
+  it("should return errors for AmountRequired", async () => {
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    transaction.fees = new BigNumber(2);
+    transaction.recipient = "0x" + "0".repeat(64);
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new AmountRequired(),
+      },
+      warnings: {},
+      estimatedFees: new BigNumber(2),
+      amount: new BigNumber(0),
+      totalSpent: new BigNumber(2),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return errors for FeeNotLoaded", async () => {
+    const account = createFixtureAccount();
+    account.balance = new BigNumber(10);
+
+    const transaction = createFixtureTransaction();
+    transaction.fees = null;
+    transaction.amount = new BigNumber(2);
+    transaction.recipient = "0x" + "0".repeat(64);
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        fees: new FeeNotLoaded(),
+      },
+      warnings: {},
+      estimatedFees: new BigNumber(0),
+      amount: new BigNumber(2),
+      totalSpent: new BigNumber(2),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return errors for NotEnoughBalance", async () => {
+    const account = createFixtureAccount();
+    account.balance = new BigNumber(1);
+
+    const transaction = createFixtureTransaction();
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = new BigNumber(2);
+    transaction.fees = new BigNumber(2);
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: new BigNumber(2),
+      amount: new BigNumber(2),
+      totalSpent: new BigNumber(4),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return errors for RecipientRequired", async () => {
+    const account = createFixtureAccount();
+    account.balance = new BigNumber(10);
+
+    const transaction = createFixtureTransaction();
+    transaction.amount = new BigNumber(2);
+    transaction.fees = new BigNumber(2);
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new RecipientRequired(),
+      },
+      warnings: {},
+      estimatedFees: new BigNumber(2),
+      amount: new BigNumber(2),
+      totalSpent: new BigNumber(4),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return errors for InvalidAddress", async () => {
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    transaction.amount = new BigNumber(2);
+    transaction.fees = new BigNumber(2);
+    transaction.recipient = "0x";
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new InvalidAddress(),
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: new BigNumber(2),
+      amount: new BigNumber(2),
+      totalSpent: new BigNumber(4),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return errors for InvalidAddressBecauseDestinationIsAlsoSource", async () => {
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    transaction.amount = new BigNumber(2);
+    transaction.fees = new BigNumber(2);
+    transaction.recipient = "0x" + "0".repeat(64);
+    account.freshAddress = transaction.recipient;
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: new BigNumber(2),
+      amount: new BigNumber(2),
+      totalSpent: new BigNumber(4),
+    };
+
+    expect(result).toEqual(expected);
+  });
+});

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

@@ -0,0 +1,108 @@
+import BigNumber from "bignumber.js";
+import { createBridges } from "../../bridge";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+
+const signer = jest.fn();
+const bridge = createBridges(signer);
+
+describe("Aptos bridge interface ", () => {
+  describe("currencyBridge", () => {
+    it("should have a preload method that returns a promise", async () => {
+      const cryptoCurrency = getCryptoCurrencyById("aptos");
+      const result = bridge.currencyBridge.preload(cryptoCurrency);
+      expect(result).toBeInstanceOf(Promise);
+      await expect(result).resolves.toEqual({});
+    });
+
+    it("should have a hydrate method that is a function", () => {
+      expect(bridge.currencyBridge.hydrate).toBeDefined();
+      expect(typeof bridge.currencyBridge.hydrate).toBe("function");
+      const cryptoCurrency = getCryptoCurrencyById("aptos");
+      const result = bridge.currencyBridge.hydrate({}, cryptoCurrency);
+      expect(result).toBeUndefined();
+    });
+
+    it("should have a scanAccounts method that is a function", () => {
+      expect(bridge.currencyBridge.scanAccounts).toBeDefined();
+      expect(typeof bridge.currencyBridge.scanAccounts).toBe("function");
+      const cryptoCurrency = getCryptoCurrencyById("aptos");
+      const deviceId = "test-device";
+      const result = bridge.currencyBridge.scanAccounts({
+        currency: cryptoCurrency,
+        deviceId,
+        syncConfig: { paginationConfig: {} },
+      });
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("accountBridge", () => {
+    it("should contain all methods", () => {
+      expect(bridge.accountBridge.estimateMaxSpendable).toBeDefined();
+      expect(typeof bridge.accountBridge.estimateMaxSpendable).toBe("function");
+      expect(bridge.accountBridge.createTransaction).toBeDefined();
+      expect(typeof bridge.accountBridge.createTransaction).toBe("function");
+      expect(bridge.accountBridge.updateTransaction).toBeDefined();
+      expect(typeof bridge.accountBridge.updateTransaction).toBe("function");
+      expect(bridge.accountBridge.getTransactionStatus).toBeDefined();
+      expect(typeof bridge.accountBridge.getTransactionStatus).toBe("function");
+      expect(bridge.accountBridge.prepareTransaction).toBeDefined();
+      expect(typeof bridge.accountBridge.prepareTransaction).toBe("function");
+      expect(bridge.accountBridge.sync).toBeDefined();
+      expect(typeof bridge.accountBridge.sync).toBe("function");
+      expect(bridge.accountBridge.receive).toBeDefined();
+      expect(typeof bridge.accountBridge.receive).toBe("function");
+      expect(bridge.accountBridge.signOperation).toBeDefined();
+      expect(typeof bridge.accountBridge.signOperation).toBe("function");
+      expect(bridge.accountBridge.broadcast).toBeDefined();
+      expect(typeof bridge.accountBridge.broadcast).toBe("function");
+      expect(bridge.currencyBridge.hydrate).toBeDefined();
+      expect(typeof bridge.currencyBridge.hydrate).toBe("function");
+      expect(bridge.currencyBridge.preload).toBeDefined();
+      expect(typeof bridge.currencyBridge.preload).toBe("function");
+      expect(bridge.currencyBridge.scanAccounts).toBeDefined();
+      expect(typeof bridge.currencyBridge.scanAccounts).toBe("function");
+    });
+  });
+
+  describe("updateTransaction", () => {
+    it("should update the transaction with the given patch", () => {
+      const initialTransaction = {
+        amount: new BigNumber(100),
+        recipient: "address1",
+        mode: "send",
+        family: "aptos" as const,
+        options: { maxGasAmount: "", gasUnitPrice: "" },
+      };
+      const patch = { amount: new BigNumber(200) };
+      const updatedTransaction = bridge.accountBridge.updateTransaction(initialTransaction, patch);
+      expect(updatedTransaction).toEqual({
+        amount: new BigNumber(200),
+        recipient: "address1",
+        mode: "send",
+        family: "aptos" as const,
+        options: { maxGasAmount: "", gasUnitPrice: "" },
+      });
+    });
+
+    it("should not modify the original transaction object", () => {
+      const initialTransaction = {
+        amount: new BigNumber(100),
+        recipient: "address1",
+        mode: "send",
+        family: "aptos" as const,
+        options: { maxGasAmount: "", gasUnitPrice: "" },
+      };
+      const patch = { amount: new BigNumber(200) };
+      const updatedTransaction = bridge.accountBridge.updateTransaction(initialTransaction, patch);
+      expect(initialTransaction).toEqual({
+        amount: new BigNumber(100),
+        recipient: "address1",
+        mode: "send",
+        family: "aptos" as const,
+        options: { maxGasAmount: "", gasUnitPrice: "" },
+      });
+      expect(updatedTransaction).not.toBe(initialTransaction);
+    });
+  });
+});