@ledgerhq/coin-aptos 2.5.1 → 2.5.2-nightly.0

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

@@ -12,9 +12,38 @@ import {
   InvalidAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughBalance,
-  NotEnoughBalanceFees,
+  NotEnoughToRestake,
+  NotEnoughToStake,
+  NotEnoughToUnstake,
   RecipientRequired,
 } from "@ledgerhq/errors";
+import { MIN_COINS_ON_SHARES_POOL } from "../../constants";
+
+const aptosResources = {
+  activeBalance: BigNumber(45988443248),
+  pendingInactiveBalance: BigNumber(67874023),
+  inactiveBalance: BigNumber(567600900),
+  stakingPositions: [
+    {
+      active: BigNumber(123456789),
+      inactive: BigNumber(567567567),
+      pendingInactive: BigNumber(5345),
+      validatorId: "validator-1",
+    },
+    {
+      active: BigNumber(3),
+      inactive: BigNumber(33333),
+      pendingInactive: BigNumber(67868678),
+      validatorId: "validator-2",
+    },
+    {
+      active: BigNumber(45864986459),
+      inactive: BigNumber(0),
+      pendingInactive: BigNumber(0),
+      validatorId: "validator-3",
+    },
+  ],
+};
 
 describe("getTransactionStatus Test", () => {
   it("should return error for AmountRequired", async () => {
@@ -53,6 +82,7 @@ describe("getTransactionStatus Test", () => {
     const expected = {
       errors: {
         fees: new FeeNotLoaded(),
+        amount: new NotEnoughBalance(),
       },
       warnings: {},
       estimatedFees: BigNumber(0),
@@ -200,7 +230,7 @@ describe("getTransactionStatus Test", () => {
 
     const expected = {
       errors: {
-        amount: new NotEnoughBalanceFees(),
+        amount: new NotEnoughBalance(),
       },
       warnings: {},
       estimatedFees: BigNumber(0),
@@ -225,6 +255,7 @@ describe("getTransactionStatus Test", () => {
     const expected = {
       errors: {
         recipient: new RecipientRequired(),
+        amount: new NotEnoughBalance(),
       },
       warnings: {},
       estimatedFees: BigNumber(2),
@@ -315,7 +346,6 @@ describe("getTransactionStatus Test", () => {
 
     const transaction = createFixtureTransaction();
     transaction.recipient = "0x" + "0".repeat(64);
-    transaction.amount = BigNumber(2);
     transaction.fees = BigNumber(2);
     transaction.useAllAmount = true;
 
@@ -331,4 +361,218 @@ describe("getTransactionStatus Test", () => {
 
     expect(result).toEqual(expected);
   });
+
+  it("should return not enough balance if trying to stake more than the current balance", async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(123456),
+      spendableBalance: BigNumber(123456),
+    });
+
+    const transaction = createFixtureTransaction({ mode: "stake", amount: BigNumber(123453336) });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it(`should return not enough balance to stake if trying to stake less than ${MIN_COINS_ON_SHARES_POOL} APT`, async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(123456),
+      spendableBalance: BigNumber(123456),
+    });
+
+    const transaction = createFixtureTransaction({ mode: "stake", amount: BigNumber(5) });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughToStake(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it(`should return not enough balance to stake if trying to stake the max balance but it is less than ${MIN_COINS_ON_SHARES_POOL} APT`, async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+    });
+
+    const transaction = createFixtureTransaction({ mode: "stake", useAllAmount: true });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughToStake(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it("should return an error if there's no staking position to restake", async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+    });
+
+    const transaction = createFixtureTransaction({ mode: "restake" });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new RecipientRequired(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it("should return an error if there's not enough pending inactive balance", async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+      aptosResources,
+    });
+
+    const transaction = createFixtureTransaction({
+      mode: "restake",
+      recipient: "validator-1",
+      amount: BigNumber(67874022223),
+      fees: BigNumber(1),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it(`should return not enough amount if trying to restake but it is less than ${MIN_COINS_ON_SHARES_POOL} APT`, async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+      aptosResources,
+    });
+
+    const transaction = createFixtureTransaction({
+      mode: "restake",
+      recipient: "validator-2",
+      amount: BigNumber(4),
+      fees: BigNumber(1),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughToRestake(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it("should return an error if there's no staking position to unstake", async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+    });
+
+    const transaction = createFixtureTransaction({ mode: "unstake" });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new RecipientRequired(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it(`should return not enough to unstake if the amount to unstake is less than ${MIN_COINS_ON_SHARES_POOL} APT`, async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+      aptosResources,
+    });
+
+    const transaction = createFixtureTransaction({
+      mode: "unstake",
+      recipient: "validator-2",
+      amount: BigNumber(2),
+      fees: BigNumber(0.5),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughToUnstake(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it("should return an error if there's no staking position to withdraw", async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+    });
+
+    const transaction = createFixtureTransaction({ mode: "withdraw" });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        recipient: new RecipientRequired(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
+
+  it("should return an error if there's not enough inactive balance to withdraw", async () => {
+    const account = createFixtureAccount({
+      balance: BigNumber(4),
+      spendableBalance: BigNumber(4),
+      aptosResources,
+    });
+
+    const transaction = createFixtureTransaction({
+      mode: "restake",
+      recipient: "validator-1",
+      amount: BigNumber(56756756745),
+      fees: BigNumber(1),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = {
+      errors: {
+        amount: new NotEnoughBalance(),
+      },
+    };
+
+    expect(result).toMatchObject(expected);
+  });
 });

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

@@ -1,3 +1,7 @@
+jest.mock("../../network/validators", () => ({
+  getValidators: jest.fn(() => Promise.resolve([])),
+}));
+
 import BigNumber from "bignumber.js";
 import { createBridges } from "../../bridge";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
@@ -11,7 +15,7 @@ describe("Aptos bridge interface ", () => {
       const cryptoCurrency = getCryptoCurrencyById("aptos");
       const result = bridge.currencyBridge.preload(cryptoCurrency);
       expect(result).toBeInstanceOf(Promise);
-      await expect(result).resolves.toEqual({});
+      await expect(result).resolves.toMatchObject({ validatorsWithMeta: [] });
     });
 
     it("should have a hydrate method that is a function", () => {

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

@@ -1,6 +1,6 @@
 import { EntryFunctionPayloadResponse } from "@aptos-labs/ts-sdk";
 import BigNumber from "bignumber.js";
-import { APTOS_COIN_CHANGE, DIRECTION } from "../../constants";
+import { APTOS_COIN_CHANGE, OP_TYPE } from "../../constants";
 import { getMaxSendBalance, getBlankOperation, txsToOps } from "../../bridge/logic";
 import type { AptosTransaction, TransactionOptions } from "../../types";
 import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
@@ -19,7 +19,7 @@ describe("Aptos logic ", () => {
       const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
+      const result = getMaxSendBalance(account, transaction, gas, gasPrice);
       expect(result.isEqualTo(amount.minus(gas.multipliedBy(gasPrice)))).toBe(true);
     });
 
@@ -28,7 +28,7 @@ describe("Aptos logic ", () => {
       const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
+      const result = getMaxSendBalance(account, transaction, gas, gasPrice);
       expect(result.isEqualTo(new BigNumber(0))).toBe(true);
     });
 
@@ -37,7 +37,7 @@ describe("Aptos logic ", () => {
       const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
+      const result = getMaxSendBalance(account, transaction, gas, gasPrice);
       expect(result.isEqualTo(new BigNumber(0))).toBe(true);
     });
 
@@ -46,7 +46,7 @@ describe("Aptos logic ", () => {
       const transaction = createFixtureTransaction();
       const gas = new BigNumber(200);
       const gasPrice = new BigNumber(100);
-      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
+      const result = getMaxSendBalance(account, transaction, gas, gasPrice);
       expect(result.isEqualTo(new BigNumber(0))).toBe(true);
     });
 
@@ -56,7 +56,7 @@ describe("Aptos logic ", () => {
       const transaction = createFixtureTransaction();
       const gas = new BigNumber(0);
       const gasPrice = new BigNumber(0);
-      const result = getMaxSendBalance(gas, gasPrice, account, transaction);
+      const result = getMaxSendBalance(account, transaction, gas, gasPrice);
       expect(result.isEqualTo(amount)).toBe(true);
     });
   });
@@ -225,7 +225,7 @@ describe("Aptos sync logic ", () => {
       expect(result[0]).toEqual({
         id: expect.any(String),
         hash: "0x123",
-        type: DIRECTION.OUT,
+        type: OP_TYPE.OUT,
         value: new BigNumber(100),
         fee: new BigNumber(20000),
         blockHash: "0xabc",
@@ -424,7 +424,7 @@ describe("Aptos sync logic ", () => {
       expect(result[0]).toEqual({
         id: expect.any(String),
         hash: "0x0189",
-        type: DIRECTION.OUT,
+        type: OP_TYPE.OUT,
         value: new BigNumber(20000),
         fee: new BigNumber(20000),
         blockHash: "0xc496",
@@ -722,7 +722,7 @@ describe("Aptos sync logic ", () => {
       expect(tokenOps[0]).toEqual({
         id: expect.any(String),
         hash: "0x123",
-        type: DIRECTION.OUT,
+        type: OP_TYPE.OUT,
         value: new BigNumber(1500000),
         fee: new BigNumber(20000),
         blockHash: "0xabc",
@@ -1018,7 +1018,7 @@ describe("Aptos sync logic ", () => {
         id: expect.any(String),
         accountId: "token_account_id",
         hash: "0x10c9",
-        type: DIRECTION.IN,
+        type: OP_TYPE.IN,
         value: new BigNumber(193),
         fee: new BigNumber(20000),
         blockHash: "0xabc",

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

@@ -3,8 +3,7 @@ import { AptosAPI } from "../../network";
 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";
+import type { AptosAccount, Transaction } from "../../types";
 
 jest.mock("../../network");
 jest.mock("../../bridge/getFeesForTransaction");
@@ -12,7 +11,7 @@ jest.mock("../../bridge/logic");
 
 describe("Aptos prepareTransaction", () => {
   describe("prepareTransaction", () => {
-    let account: Account;
+    let account: AptosAccount;
     let transaction: Transaction;
 
     beforeEach(() => {
@@ -33,13 +32,14 @@ describe("Aptos prepareTransaction", () => {
         unit: { code: "APT", name: "Aptos", magnitude: 6 },
         lastSyncDate: new Date(),
         subAccounts: [],
-      } as unknown as Account;
+      } as unknown as AptosAccount;
 
       transaction = {
         amount: new BigNumber(0),
         recipient: "",
         useAllAmount: false,
         fees: new BigNumber(0),
+        mode: "send",
       } as Transaction;
     });
 

package/src/__tests__/bridge/serialization.ts

@@ -0,0 +1,103 @@
+import BigNumber from "bignumber.js";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  fromAptosResourcesRaw,
+  toAptosResourcesRaw,
+} from "../../bridge/serialization";
+import { createFixtureAccount } from "../../bridge/bridge.fixture";
+import { AccountRaw } from "@ledgerhq/types-live";
+import { AptosAccountRaw } from "../../types";
+
+describe("serialization", () => {
+  const stakingPositions = [
+    {
+      active: BigNumber(123456789),
+      inactive: BigNumber(567567567),
+      pendingInactive: BigNumber(5345),
+      validatorId: "validator-1",
+    },
+    {
+      active: BigNumber(0),
+      inactive: BigNumber(33333),
+      pendingInactive: BigNumber(67868678),
+      validatorId: "validator-2",
+    },
+    {
+      active: BigNumber(45864986459),
+      inactive: BigNumber(0),
+      pendingInactive: BigNumber(0),
+      validatorId: "validator-3",
+    },
+  ];
+
+  const aptosResources = {
+    activeBalance: BigNumber(9834759839345),
+    inactiveBalance: BigNumber(789346249),
+    pendingInactiveBalance: BigNumber(0),
+    stakingPositions,
+  };
+
+  const aptosResourcesRaw = {
+    activeBalance: "9834759839345",
+    pendingInactiveBalance: "0",
+    inactiveBalance: "789346249",
+    stakingPositions: [
+      {
+        active: "123456789",
+        pendingInactive: "5345",
+        inactive: "567567567",
+        validatorId: "validator-1",
+      },
+      {
+        active: "0",
+        pendingInactive: "67868678",
+        inactive: "33333",
+        validatorId: "validator-2",
+      },
+      {
+        active: "45864986459",
+        pendingInactive: "0",
+        inactive: "0",
+        validatorId: "validator-3",
+      },
+    ],
+  };
+
+  const account = createFixtureAccount({ aptosResources });
+
+  const accountRaw = {
+    id: "1",
+    seedIdentifier: "seedIdentifier",
+    derivationMode: "",
+    index: 1,
+    freshAddress: "freshAddress",
+    freshAddressPath: "freshAddressPath",
+    balance: "1234",
+    blockHeight: 1,
+    currencyId: "aptos",
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: "",
+  };
+
+  it("toAptosResourcesRaw", () => {
+    expect(toAptosResourcesRaw(aptosResources)).toMatchObject(aptosResourcesRaw);
+  });
+
+  it("fromAptosResourcesRaw", () => {
+    expect(fromAptosResourcesRaw(aptosResourcesRaw)).toMatchObject(aptosResources);
+  });
+
+  it("assignToAccountRaw", () => {
+    assignToAccountRaw(account, accountRaw as AccountRaw);
+    expect((accountRaw as unknown as AptosAccountRaw).aptosResources).toMatchObject(
+      aptosResourcesRaw,
+    );
+  });
+
+  it("assignFromAccountRaw", () => {
+    assignFromAccountRaw(accountRaw as AccountRaw, account);
+    expect((account as unknown as AptosAccountRaw).aptosResources).toMatchObject(aptosResources);
+  });
+});