@ledgerhq/coin-celo 1.2.2-nightly.3 → 1.3.0-nightly.5

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

@@ -0,0 +1,233 @@
+import BigNumber from "bignumber.js";
+import getFeesForTransaction from "../../bridge/getFeesForTransaction";
+import { accountFixture, transactionFixture } from "../../bridge/fixtures";
+
+const chainIdMock = jest.fn();
+const nonceMock = jest.fn();
+const voteMock = jest.fn(() => ({
+  txo: {
+    encodeABI: jest.fn(() => ({ data: "vote_data" })),
+    estimateGas: jest.fn(async () => 1),
+  },
+}));
+const revokeMock = jest.fn();
+const voteSignerToAccountMock = jest.fn();
+
+jest.mock("../../network/sdk", () => {
+  return {
+    celoKit: jest.fn(() => ({
+      contracts: {
+        getLockedGold: jest.fn(async () => ({
+          address: "address",
+          lock: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "lock_data" })),
+              estimateGas: jest.fn(async () => 2),
+            },
+          })),
+          unlock: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "unlock_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          withdraw: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "withdraw_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          vote: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "vote_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          getAccountNonvotingLockedGold: jest.fn(() => BigNumber(0)),
+        })),
+        getElection: jest.fn(async () => ({
+          vote: voteMock,
+          revoke: revokeMock,
+          activate: jest.fn(() => ({
+            find: jest.fn(() => ({
+              txo: {
+                encodeABI: jest.fn(() => ({ data: "vote_data" })),
+                estimateGas: jest.fn(async () => 3),
+              },
+            })),
+          })),
+          address: "vote_address",
+        })),
+        getAccounts: jest.fn(async () => ({
+          voteSignerToAccount: voteSignerToAccountMock,
+          createAccount: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "register_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          address: "register_address",
+        })),
+        getStableToken: jest.fn(async () => ({
+          address: "stable_token_address",
+          transfer: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "send_token_data" })),
+            },
+          })),
+        })),
+        getErc20: jest.fn(async () => ({
+          address: "erc20_token_address",
+          transfer: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "send_token_data" })),
+            },
+          })),
+        })),
+      },
+      connection: {
+        chainId: chainIdMock,
+        nonce: nonceMock,
+        estimateGasWithInflationFactor: jest.fn().mockReturnValue(3),
+        gasPrice: jest.fn(async () => BigNumber(2)),
+      },
+    })),
+  };
+});
+
+describe("getFeesForTransaction", () => {
+  it("should return the correct fees for a send transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: transactionFixture,
+    });
+
+    expect(fees).toEqual(BigNumber(24));
+  });
+
+  it("should return the correct fees for a revoke transaction without revoked transactions", async () => {
+    revokeMock.mockClear();
+
+    revokeMock.mockReturnValue({
+      find: jest.fn(() => false),
+    });
+
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "revoke" },
+    });
+
+    expect(fees).toEqual(BigNumber(0));
+  });
+
+  it("should return the correct fees for a revoke transaction with revoked transactions", async () => {
+    revokeMock.mockClear();
+
+    revokeMock.mockReturnValue({
+      find: jest.fn(() => ({
+        txo: {
+          encodeABI: jest.fn(() => ({ data: "revoke_data" })),
+          estimateGas: jest.fn(async () => 2),
+        },
+      })),
+    });
+
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "revoke" },
+    });
+
+    expect(fees).toEqual(BigNumber(4));
+  });
+
+  it("should return the correct fees for a revoke transaction with revoked transactions and useAllAmount set to true", async () => {
+    revokeMock.mockClear();
+
+    revokeMock.mockReturnValue({
+      find: jest.fn(() => ({
+        txo: {
+          encodeABI: jest.fn(() => ({ data: "revoke_data" })),
+          estimateGas: jest.fn(async () => 2),
+        },
+      })),
+    });
+
+    const fees = await getFeesForTransaction({
+      account: {
+        ...accountFixture,
+        balance: BigNumber(123),
+        spendableBalance: BigNumber(123),
+        celoResources: {
+          ...accountFixture.celoResources,
+          votes: [
+            {
+              activatable: true,
+              amount: BigNumber(10),
+              index: 0,
+              revokable: true,
+              type: "active",
+              validatorGroup: transactionFixture.recipient,
+            },
+          ],
+        },
+      },
+      transaction: { ...transactionFixture, mode: "revoke", useAllAmount: true },
+    });
+
+    expect(fees).toEqual(BigNumber(4));
+  });
+
+  it("should return the correct fees for a withdraw transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "withdraw" },
+    });
+
+    expect(fees).toEqual(BigNumber(6));
+  });
+
+  it("should return the correct fees for a vote transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "vote" },
+    });
+
+    expect(fees).toEqual(BigNumber(2));
+  });
+
+  it("should return the correct fees for a lock transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "lock" },
+    });
+
+    expect(fees).toEqual(BigNumber(4));
+  });
+
+  it("should return the correct fees for a unlock transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "unlock" },
+    });
+
+    expect(fees).toEqual(BigNumber(6));
+  });
+
+  it("should return the correct fees for an activate transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "activate" },
+    });
+
+    expect(fees).toEqual(BigNumber(6));
+  });
+
+  it("should return the correct fees for a register transaction", async () => {
+    const fees = await getFeesForTransaction({
+      account: { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      transaction: { ...transactionFixture, mode: "register" },
+    });
+
+    expect(fees).toEqual(BigNumber(6));
+  });
+});

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

@@ -0,0 +1,261 @@
+import { accountFixture, transactionFixture } from "../../bridge/fixtures";
+import getTransactionStatus from "../../bridge/getTransactionStatus";
+import BigNumber from "bignumber.js";
+
+jest.mock("../../network/sdk", () => {
+  return {
+    celoKit: jest.fn(() => ({
+      contracts: {
+        getLockedGold: jest.fn(async () => ({
+          address: "address",
+          lock: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "lock_data" })),
+              estimateGas: jest.fn(async () => 2),
+            },
+          })),
+          unlock: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "unlock_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          withdraw: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "withdraw_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          vote: jest.fn(() => ({
+            txo: {
+              encodeABI: jest.fn(() => ({ data: "vote_data" })),
+              estimateGas: jest.fn(async () => 3),
+            },
+          })),
+          getAccountNonvotingLockedGold: jest.fn(() => BigNumber(100)),
+        })),
+      },
+    })),
+  };
+});
+
+describe("getTransactionStatus", () => {
+  it("should return an InvalidAddressBecauseDestinationIsAlsoSource error in case the recipient is also the sender", async () => {
+    const transactionStatus = await getTransactionStatus(
+      { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      {
+        ...transactionFixture,
+        recipient: accountFixture.freshAddress,
+        fees: BigNumber(2),
+      },
+    );
+
+    expect(transactionStatus.errors["recipient"].name).toEqual(
+      "InvalidAddressBecauseDestinationIsAlsoSource",
+    );
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an FeeNotLoaded error in case the transaction is missing fees", async () => {
+    const transactionStatus = await getTransactionStatus(
+      { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+      },
+    );
+
+    expect(transactionStatus.errors["fees"].name).toEqual("FeeNotLoaded");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an NotEnoughBalance error in case the transaction is more than the account balance", async () => {
+    const transactionStatus = await getTransactionStatus(
+      { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        fees: BigNumber(2),
+        amount: BigNumber(88888),
+      },
+    );
+
+    expect(transactionStatus.errors["amount"].name).toEqual("NotEnoughBalance");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an RecipientRequired error in case the transaction does not have a recipient address", async () => {
+    const transactionStatus = await getTransactionStatus(
+      { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      {
+        ...transactionFixture,
+        recipient: "",
+        fees: BigNumber(2),
+      },
+    );
+
+    expect(transactionStatus.errors["recipient"].name).toEqual("RecipientRequired");
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an InvalidAddress error in case the transaction does not have a valid recipient address", async () => {
+    const transactionStatus = await getTransactionStatus(
+      { ...accountFixture, balance: BigNumber(123), spendableBalance: BigNumber(123) },
+      {
+        ...transactionFixture,
+        fees: BigNumber(2),
+      },
+    );
+
+    expect(transactionStatus.errors["recipient"].name).toEqual("InvalidAddress");
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return a CeloAllFundsWarning warning in case of a send or lock transaction is using all the balance above the safety buffer", async () => {
+    const transactionStatus = await getTransactionStatus(
+      {
+        ...accountFixture,
+        balance: BigNumber(10000000000000000),
+        spendableBalance: BigNumber(10000000000000000),
+        celoResources: {
+          ...accountFixture.celoResources,
+          lockedBalance: BigNumber(44444),
+        },
+      },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        amount: BigNumber(9000000000000000),
+        fees: BigNumber(2),
+      },
+    );
+
+    expect(transactionStatus.warnings["amount"].name).toEqual("CeloAllFundsWarning");
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+  });
+
+  it("should not return any error or warning", async () => {
+    const transactionStatus = await getTransactionStatus(
+      {
+        ...accountFixture,
+        balance: BigNumber(10000000000000000),
+        spendableBalance: BigNumber(10000000000000000),
+        celoResources: {
+          ...accountFixture.celoResources,
+          lockedBalance: BigNumber(44444),
+        },
+      },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        fees: BigNumber(2),
+        useAllAmount: true,
+        mode: "vote",
+      },
+    );
+
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an AmountRequired error", async () => {
+    const transactionStatus = await getTransactionStatus(
+      {
+        ...accountFixture,
+        balance: BigNumber(10000000000000000),
+        spendableBalance: BigNumber(10000000000000000),
+        celoResources: {
+          ...accountFixture.celoResources,
+          lockedBalance: BigNumber(44444),
+        },
+      },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        fees: BigNumber(2),
+        amount: BigNumber(0),
+      },
+    );
+
+    expect(transactionStatus.errors["amount"].name).toEqual("AmountRequired");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an NotEnoughBalance error for a vote transaction where the amount is higher than the total non-voting locked balance", async () => {
+    const transactionStatus = await getTransactionStatus(
+      {
+        ...accountFixture,
+        balance: BigNumber(10000000000000000),
+        spendableBalance: BigNumber(10000000000000000),
+        celoResources: {
+          ...accountFixture.celoResources,
+          lockedBalance: BigNumber(44444),
+        },
+      },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        fees: BigNumber(2),
+        amount: BigNumber(200),
+        mode: "vote",
+      },
+    );
+
+    expect(transactionStatus.errors["amount"].name).toEqual("NotEnoughBalance");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+
+  it("should return an NotEnoughBalance error for a revoke transaction where the amount is higher than the total non-voting locked balance", async () => {
+    const transactionStatus = await getTransactionStatus(
+      {
+        ...accountFixture,
+        balance: BigNumber(10000000000000000),
+        spendableBalance: BigNumber(10000000000000000),
+        celoResources: {
+          ...accountFixture.celoResources,
+          lockedBalance: BigNumber(44444),
+          votes: [
+            {
+              activatable: true,
+              amount: BigNumber(109),
+              index: 0,
+              revokable: true,
+              type: "active",
+              validatorGroup: transactionFixture.recipient,
+            },
+          ],
+        },
+      },
+      {
+        ...transactionFixture,
+        recipient: "0x79D5A290D7ba4b99322d91b577589e8d0BF87072",
+        useAllAmount: true,
+        fees: BigNumber(2),
+        mode: "revoke",
+      },
+    );
+
+    expect(transactionStatus.errors).not.toHaveProperty("amount");
+    expect(transactionStatus.errors).not.toHaveProperty("fees");
+    expect(transactionStatus.errors).not.toHaveProperty("recipient");
+    expect(Object.keys(transactionStatus.warnings).length).toEqual(0);
+  });
+});