@ledgerhq/coin-aptos 2.0.0-nightly.5 → 2.1.0-next.0

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

@@ -1,11 +1,16 @@
 import BigNumber from "bignumber.js";
-import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import {
+  createFixtureAccount,
+  createFixtureAccountWithSubAccount,
+  createFixtureTransaction,
+  createFixtureTransactionWithSubAccount,
+} from "../../bridge/bridge.fixture";
 import * as getFeesForTransaction from "../../bridge/getFeesForTransaction";
-import { AptosAPI } from "../../api";
+import { AptosAPI } from "../../network";
 
 let simulateTransaction = jest.fn();
 
-jest.mock("../../api", () => {
+jest.mock("../../network", () => {
   return {
     AptosAPI: function () {
       return {
@@ -24,16 +29,18 @@ jest.mock("@aptos-labs/ts-sdk", () => {
   };
 });
 
-jest.mock("../../bridge/logic", () => {
-  return {
-    DEFAULT_GAS: 201,
-    DEFAULT_GAS_PRICE: 101,
-    ESTIMATE_GAS_MUL: 1,
-    normalizeTransactionOptions: jest.fn(),
-  };
-});
+const mockedGetTokenAccount = jest.fn();
 
 describe("getFeesForTransaction Test", () => {
+  beforeEach(() => {
+    jest.mock("../../bridge/logic", () => ({
+      DEFAULT_GAS: 201,
+      DEFAULT_GAS_PRICE: 101,
+      ESTIMATE_GAS_MUL: 1,
+      normalizeTransactionOptions: jest.fn(),
+      getTokenAccount: mockedGetTokenAccount,
+    }));
+  });
   describe("when using getFee", () => {
     describe("with vm_status as INSUFFICIENT_BALANCE", () => {
       it("should return a fee estimation object", async () => {
@@ -46,6 +53,7 @@ describe("getFeesForTransaction Test", () => {
             gas_unit_price: "102",
           },
         ]);
+        mockedGetTokenAccount.mockReturnValue(undefined);
 
         const account = createFixtureAccount();
         const transaction = createFixtureTransaction();
@@ -68,6 +76,40 @@ describe("getFeesForTransaction Test", () => {
 
         expect(result).toEqual(expected);
       });
+
+      it("should return a fee estimation object for the token transaction", async () => {
+        simulateTransaction = jest.fn(() => [
+          {
+            success: true,
+            vm_status: [],
+            expiration_timestamp_secs: 5,
+            gas_used: "202",
+            gas_unit_price: "102",
+          },
+        ]);
+        mockedGetTokenAccount.mockReturnValue(undefined);
+
+        const account = createFixtureAccountWithSubAccount("coin");
+        const transaction = createFixtureTransactionWithSubAccount();
+        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", () => {
@@ -81,6 +123,7 @@ describe("getFeesForTransaction Test", () => {
             gas_unit_price: "100",
           },
         ]);
+        mockedGetTokenAccount.mockReturnValue(undefined);
 
         const account = createFixtureAccount();
         const transaction = createFixtureTransaction();
@@ -95,6 +138,44 @@ describe("getFeesForTransaction Test", () => {
         }).rejects.toThrow("Simulation failed with following error: DUMMY_STATE");
       });
     });
+
+    describe("with vm_status as MAX_GAS_UNITS_BELOW_MIN_TRANSACTION_GAS_UNITS", () => {
+      it("should return a fee estimation object with GasInsuficeinetBalance error", async () => {
+        simulateTransaction = jest.fn(() => [
+          {
+            success: false,
+            vm_status: ["MAX_GAS_UNITS_BELOW_MIN_TRANSACTION_GAS_UNITS"],
+            expiration_timestamp_secs: 5,
+            gas_used: "0",
+            gas_unit_price: "100",
+          },
+        ]);
+        mockedGetTokenAccount.mockReturnValue(undefined);
+
+        const account = createFixtureAccountWithSubAccount("coin");
+        const transaction = createFixtureTransactionWithSubAccount();
+        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(0),
+          estimate: {
+            maxGasAmount: "0",
+            gasUnitPrice: "100",
+          },
+          errors: {
+            maxGasAmount: "GasInsufficientBalance",
+          },
+        };
+
+        expect(result).toEqual(expected);
+      });
+    });
   });
 
   describe("when using getEstimatedGas", () => {
@@ -109,6 +190,7 @@ describe("getFeesForTransaction Test", () => {
             gas_unit_price: "102",
           },
         ]);
+        mockedGetTokenAccount.mockReturnValue(undefined);
 
         const account = createFixtureAccount();
         const transaction = createFixtureTransaction();
@@ -152,6 +234,8 @@ describe("getFeesForTransaction Test", () => {
             gas_unit_price: "102",
           },
         ]);
+        mockedGetTokenAccount.mockReturnValue(undefined);
+
         const account = createFixtureAccount();
         account.xpub = "xpub";
         const transaction = createFixtureTransaction();
@@ -186,4 +270,55 @@ describe("getFeesForTransaction Test", () => {
       });
     });
   });
+
+  describe("when key is in cache from a token account", () => {
+    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",
+        },
+      ]);
+      mockedGetTokenAccount.mockReturnValue(undefined);
+
+      const account = createFixtureAccountWithSubAccount("coin");
+      account.xpub = "xpub";
+      const transaction = createFixtureTransactionWithSubAccount();
+      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

@@ -1,5 +1,10 @@
 import BigNumber from "bignumber.js";
-import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import {
+  createFixtureAccount,
+  createFixtureAccountWithSubAccount,
+  createFixtureTransaction,
+  createFixtureTransactionWithSubAccount,
+} from "../../bridge/bridge.fixture";
 import getTransactionStatus from "../../bridge/getTransactionStatus";
 import {
   AmountRequired,
@@ -7,15 +12,16 @@ import {
   InvalidAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughBalance,
+  NotEnoughBalanceFees,
   RecipientRequired,
 } from "@ledgerhq/errors";
 
 describe("getTransactionStatus Test", () => {
-  it("should return errors for AmountRequired", async () => {
+  it("should return error for AmountRequired", async () => {
     const account = createFixtureAccount();
     const transaction = createFixtureTransaction();
 
-    transaction.fees = new BigNumber(2);
+    transaction.fees = BigNumber(2);
     transaction.recipient = "0x" + "0".repeat(64);
 
     const result = await getTransactionStatus(account, transaction);
@@ -25,21 +31,21 @@ describe("getTransactionStatus Test", () => {
         amount: new AmountRequired(),
       },
       warnings: {},
-      estimatedFees: new BigNumber(2),
-      amount: new BigNumber(0),
-      totalSpent: new BigNumber(2),
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(0),
+      totalSpent: BigNumber(2),
     };
 
     expect(result).toEqual(expected);
   });
 
-  it("should return errors for FeeNotLoaded", async () => {
+  it("should return error for FeeNotLoaded", async () => {
     const account = createFixtureAccount();
-    account.balance = new BigNumber(10);
+    account.spendableBalance = BigNumber(10);
 
     const transaction = createFixtureTransaction();
     transaction.fees = null;
-    transaction.amount = new BigNumber(2);
+    transaction.amount = BigNumber(2);
     transaction.recipient = "0x" + "0".repeat(64);
 
     const result = await getTransactionStatus(account, transaction);
@@ -49,22 +55,71 @@ describe("getTransactionStatus Test", () => {
         fees: new FeeNotLoaded(),
       },
       warnings: {},
-      estimatedFees: new BigNumber(0),
-      amount: new BigNumber(2),
-      totalSpent: new BigNumber(2),
+      estimatedFees: BigNumber(0),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(2),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return error for NotEnoughBalance", async () => {
+    const account = createFixtureAccount();
+    account.spendableBalance = BigNumber(1);
+
+    const transaction = createFixtureTransaction();
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(4),
     };
 
     expect(result).toEqual(expected);
   });
 
-  it("should return errors for NotEnoughBalance", async () => {
+  it("should return error for NotEnoughBalance and amount equal to zero with use all amount option", async () => {
     const account = createFixtureAccount();
-    account.balance = new BigNumber(1);
+    account.spendableBalance = BigNumber(1);
 
     const transaction = createFixtureTransaction();
     transaction.recipient = "0x" + "0".repeat(64);
-    transaction.amount = new BigNumber(2);
-    transaction.fees = new BigNumber(2);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
+    transaction.useAllAmount = true;
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(0),
+      totalSpent: BigNumber(2),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return error for NotEnoughBalance for token account when not enough tokens", async () => {
+    const account = createFixtureAccountWithSubAccount("coin");
+    account.spendableBalance = BigNumber(300);
+
+    const transaction = createFixtureTransactionWithSubAccount();
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = BigNumber(2000);
+    transaction.fees = BigNumber(200);
 
     const result = await getTransactionStatus(account, transaction);
 
@@ -73,21 +128,97 @@ describe("getTransactionStatus Test", () => {
         amount: new NotEnoughBalance(),
       },
       warnings: {},
-      estimatedFees: new BigNumber(2),
-      amount: new BigNumber(2),
-      totalSpent: new BigNumber(4),
+      estimatedFees: BigNumber(200),
+      amount: BigNumber(2000),
+      totalSpent: BigNumber(2000),
     };
 
     expect(result).toEqual(expected);
   });
 
-  it("should return errors for RecipientRequired", async () => {
+  it("should return error for NotEnoughBalance with use all amount option", async () => {
     const account = createFixtureAccount();
-    account.balance = new BigNumber(10);
+    account.spendableBalance = BigNumber(1);
 
     const transaction = createFixtureTransaction();
-    transaction.amount = new BigNumber(2);
-    transaction.fees = new BigNumber(2);
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
+    transaction.useAllAmount = true;
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(0),
+      totalSpent: BigNumber(2),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return error for NotEnoughBalance for token account with use all amount option when not enough fees", async () => {
+    const account = createFixtureAccountWithSubAccount("coin");
+    account.spendableBalance = BigNumber(10);
+
+    const transaction = createFixtureTransactionWithSubAccount();
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = BigNumber(2000);
+    transaction.fees = BigNumber(200);
+    transaction.useAllAmount = true;
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: BigNumber(200),
+      amount: BigNumber(1000),
+      totalSpent: BigNumber(1000),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return error for NotEnoughBalanceFees", async () => {
+    const account = createFixtureAccountWithSubAccount("coin");
+    account.spendableBalance = BigNumber(1);
+
+    const transaction = createFixtureTransactionWithSubAccount();
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(0);
+    transaction.errors = { maxGasAmount: "GasInsufficientBalance" };
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalanceFees(),
+      },
+      warnings: {},
+      estimatedFees: BigNumber(0),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(2),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return error for RecipientRequired", async () => {
+    const account = createFixtureAccount();
+    account.spendableBalance = BigNumber(10);
+
+    const transaction = createFixtureTransaction();
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
+    transaction.recipient = "";
 
     const result = await getTransactionStatus(account, transaction);
 
@@ -96,20 +227,20 @@ describe("getTransactionStatus Test", () => {
         recipient: new RecipientRequired(),
       },
       warnings: {},
-      estimatedFees: new BigNumber(2),
-      amount: new BigNumber(2),
-      totalSpent: new BigNumber(4),
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(4),
     };
 
     expect(result).toEqual(expected);
   });
 
-  it("should return errors for InvalidAddress", async () => {
+  it("should return error for InvalidAddress", async () => {
     const account = createFixtureAccount();
     const transaction = createFixtureTransaction();
 
-    transaction.amount = new BigNumber(2);
-    transaction.fees = new BigNumber(2);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
     transaction.recipient = "0x";
 
     const result = await getTransactionStatus(account, transaction);
@@ -120,20 +251,20 @@ describe("getTransactionStatus Test", () => {
         amount: new NotEnoughBalance(),
       },
       warnings: {},
-      estimatedFees: new BigNumber(2),
-      amount: new BigNumber(2),
-      totalSpent: new BigNumber(4),
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(4),
     };
 
     expect(result).toEqual(expected);
   });
 
-  it("should return errors for InvalidAddressBecauseDestinationIsAlsoSource", async () => {
+  it("should return error for InvalidAddressBecauseDestinationIsAlsoSource", async () => {
     const account = createFixtureAccount();
     const transaction = createFixtureTransaction();
 
-    transaction.amount = new BigNumber(2);
-    transaction.fees = new BigNumber(2);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
     transaction.recipient = "0x" + "0".repeat(64);
     account.freshAddress = transaction.recipient;
 
@@ -145,9 +276,57 @@ describe("getTransactionStatus Test", () => {
         amount: new NotEnoughBalance(),
       },
       warnings: {},
-      estimatedFees: new BigNumber(2),
-      amount: new BigNumber(2),
-      totalSpent: new BigNumber(4),
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(4),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return error for RecipientRequired", async () => {
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
+    transaction.recipient = "";
+    account.freshAddress = transaction.recipient;
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new RecipientRequired(),
+        amount: new NotEnoughBalance(),
+      },
+      warnings: {},
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(2),
+      totalSpent: BigNumber(4),
+    };
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return right amount and total spent with use all amount option", async () => {
+    const account = createFixtureAccount();
+    account.spendableBalance = BigNumber(10);
+
+    const transaction = createFixtureTransaction();
+    transaction.recipient = "0x" + "0".repeat(64);
+    transaction.amount = BigNumber(2);
+    transaction.fees = BigNumber(2);
+    transaction.useAllAmount = true;
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {},
+      warnings: {},
+      estimatedFees: BigNumber(2),
+      amount: BigNumber(8),
+      totalSpent: BigNumber(10),
     };
 
     expect(result).toEqual(expected);