@ledgerhq/coin-evm 0.2.0-next.0

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

@@ -0,0 +1,123 @@
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import BigNumber from "bignumber.js";
+import * as rpcAPI from "../api/rpc.common";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { makeAccount, makeTokenAccount } from "../testUtils";
+import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../types";
+
+const tokenAccount = {
+  ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
+  balance: new BigNumber(6969),
+};
+const account = {
+  ...makeAccount("0xkvn", getCryptoCurrencyById("ethereum"), [tokenAccount]),
+  balance: new BigNumber(42069000000),
+};
+
+jest
+  .spyOn(rpcAPI, "getGasEstimation")
+  .mockImplementation(async () => new BigNumber(21000));
+jest.spyOn(rpcAPI, "getFeesEstimation").mockImplementation(async () => ({
+  gasPrice: new BigNumber(10000),
+  maxFeePerGas: new BigNumber(10000),
+  maxPriorityFeePerGas: new BigNumber(0),
+}));
+
+describe("EVM Family", () => {
+  describe("estimateMaxSpendable.ts", () => {
+    it("should get a max spendable of the account balance minus the EIP1559 coin tx", async () => {
+      const eip1559Tx: EvmTransactionEIP1559 = {
+        amount: new BigNumber(100),
+        useAllAmount: false,
+        recipient: "0xlmb",
+        family: "evm",
+        mode: "send",
+        nonce: 0,
+        gasLimit: new BigNumber(0),
+        chainId: 1,
+        maxFeePerGas: new BigNumber(0),
+        maxPriorityFeePerGas: new BigNumber(0),
+        type: 2,
+      };
+      const amount = await estimateMaxSpendable({
+        account,
+        transaction: eip1559Tx,
+      });
+      const gasLimit = await rpcAPI.getGasEstimation(account, eip1559Tx);
+      const { maxFeePerGas } = await rpcAPI.getFeesEstimation(account.currency);
+      const estimatedFees = gasLimit.times(maxFeePerGas!);
+      expect(amount).toEqual(account.balance.minus(estimatedFees));
+    });
+
+    it("should get a max spendable of the account balance minus the legacy coin tx", async () => {
+      const legacyTx: EvmTransactionLegacy = {
+        amount: new BigNumber(100),
+        useAllAmount: false,
+        recipient: "0xlmb",
+        family: "evm",
+        mode: "send",
+        nonce: 0,
+        gasLimit: new BigNumber(0),
+        chainId: 1,
+        gasPrice: new BigNumber(0),
+        type: 0,
+      };
+      const amount = await estimateMaxSpendable({
+        account,
+        transaction: legacyTx,
+      });
+      const gasLimit = await rpcAPI.getGasEstimation(account, legacyTx);
+      const { gasPrice } = await rpcAPI.getFeesEstimation(account.currency);
+      const estimatedFees = gasLimit.times(gasPrice!);
+      expect(amount).toEqual(account.balance.minus(estimatedFees));
+    });
+
+    it("should get a max spendable of the account balance minus the EIP1559 token tx", async () => {
+      const eip1559Tx: EvmTransactionEIP1559 = {
+        amount: new BigNumber(100),
+        useAllAmount: false,
+        recipient: "0xlmb",
+        family: "evm",
+        mode: "send",
+        nonce: 0,
+        gasLimit: new BigNumber(0),
+        chainId: 1,
+        maxFeePerGas: new BigNumber(0),
+        maxPriorityFeePerGas: new BigNumber(0),
+        subAccountId: tokenAccount.id,
+        type: 2,
+      };
+
+      const amount = await estimateMaxSpendable({
+        account: tokenAccount,
+        parentAccount: account,
+        transaction: eip1559Tx,
+      });
+
+      expect(amount).toEqual(tokenAccount.balance);
+    });
+
+    it("should get a max spendable of the account balance minus the legacy token tx", async () => {
+      const legacyTx: EvmTransactionLegacy = {
+        amount: new BigNumber(100),
+        useAllAmount: false,
+        recipient: "0xlmb",
+        family: "evm",
+        mode: "send",
+        nonce: 0,
+        gasLimit: new BigNumber(0),
+        chainId: 1,
+        gasPrice: new BigNumber(0),
+        subAccountId: tokenAccount.id,
+        type: 0,
+      };
+      const amount = await estimateMaxSpendable({
+        account: tokenAccount,
+        parentAccount: account,
+        transaction: legacyTx,
+      });
+
+      expect(amount).toEqual(tokenAccount.balance);
+    });
+  });
+});

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

@@ -0,0 +1,355 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import {
+  AmountRequired,
+  ETHAddressNonEIP,
+  FeeNotLoaded,
+  GasLessThanEstimate,
+  InvalidAddress,
+  NotEnoughBalance,
+  NotEnoughGas,
+  PriorityFeeTooLow,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import getTransactionStatus from "../getTransactionStatus";
+import { makeAccount, makeTokenAccount } from "../testUtils";
+import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../types";
+
+const recipient = "0xe2ca7390e76c5A992749bB622087310d2e63ca29"; // rambo.eth
+const testData = Buffer.from("testBufferString").toString("hex");
+const tokenAccount = makeTokenAccount(
+  "0xkvn",
+  getTokenById("ethereum/erc20/usd__coin")
+);
+const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"), [
+  tokenAccount,
+]);
+const legacyTx: EvmTransactionLegacy = {
+  amount: new BigNumber(100),
+  useAllAmount: false,
+  subAccountId: "id",
+  recipient,
+  feesStrategy: "custom",
+  family: "evm",
+  mode: "send",
+  nonce: 0,
+  gasLimit: new BigNumber(21000),
+  chainId: 1,
+  data: Buffer.from(testData, "hex"),
+  gasPrice: new BigNumber(100),
+  type: 0,
+};
+const eip1559Tx: EvmTransactionEIP1559 = {
+  amount: new BigNumber(100),
+  useAllAmount: false,
+  subAccountId: "id",
+  recipient,
+  feesStrategy: "custom",
+  family: "evm",
+  mode: "send",
+  nonce: 0,
+  gasLimit: new BigNumber(21000),
+  chainId: 1,
+  data: Buffer.from(testData, "hex"),
+  maxFeePerGas: new BigNumber(100),
+  maxPriorityFeePerGas: new BigNumber(100),
+  type: 2,
+};
+
+describe("EVM Family", () => {
+  describe("getTransactionStatus.ts", () => {
+    describe("Recipient", () => {
+      it("should detect the missing recipient and have an error", async () => {
+        const tx = { ...eip1559Tx, recipient: "" };
+        const res = await getTransactionStatus(account, tx);
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            recipient: new RecipientRequired(),
+          })
+        );
+      });
+
+      it("should detect the incorrect recipient not being an eth address and have an error", async () => {
+        const tx = { ...eip1559Tx, recipient: "0xkvn" };
+        const res = await getTransactionStatus(account, tx);
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            recipient: new InvalidAddress("", {
+              currency: account.currency,
+            }),
+          })
+        );
+      });
+
+      it("should detect the recipient being an ICAP and have an error", async () => {
+        const tx = {
+          ...eip1559Tx,
+          recipient: "XE89MW3Y75UITCQ4F53YDKR25UFLB1640YM", // ICAP version of recipient address
+        };
+        const res = await getTransactionStatus(account, tx);
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            recipient: new InvalidAddress("", {
+              currency: account.currency,
+            }),
+          })
+        );
+      });
+
+      it("should detect the recipient not being an EIP55 address and have an warning", async () => {
+        const tx = { ...eip1559Tx, recipient: recipient.toLowerCase() };
+        const res = await getTransactionStatus(account, tx);
+        expect(res.warnings).toEqual(
+          expect.objectContaining({
+            recipient: new ETHAddressNonEIP(),
+          })
+        );
+      });
+    });
+
+    describe("Amount", () => {
+      it("should detect tx without amount and have an error", async () => {
+        const tx = {
+          ...eip1559Tx,
+          amount: new BigNumber(0),
+          data: undefined,
+        };
+        const res = await getTransactionStatus(account, tx);
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            amount: new AmountRequired(),
+          })
+        );
+      });
+
+      it("should detect tx without amount but with data and not return error", async () => {
+        const tx = {
+          ...eip1559Tx,
+          amount: new BigNumber(0),
+        };
+        const res = await getTransactionStatus(
+          { ...account, balance: new BigNumber(10000000) },
+          tx
+        );
+
+        expect(res.errors).toEqual({});
+      });
+
+      it("should detect tx without amount (because of useAllAmount) but from tokenAccount and not return error", async () => {
+        const tx = {
+          ...eip1559Tx,
+          amount: new BigNumber(0),
+          useAllAmount: true,
+          subAccountId: tokenAccount.id,
+        };
+        const res = await getTransactionStatus(
+          {
+            ...account,
+            balance: new BigNumber(10000000),
+            subAccounts: [
+              {
+                ...tokenAccount,
+                balance: new BigNumber(10),
+              },
+            ],
+          },
+          tx
+        );
+
+        expect(res.errors).toEqual({});
+      });
+
+      it("should detect account not having enough balance for a tx and have an error", async () => {
+        const res = await getTransactionStatus(
+          { ...account, balance: new BigNumber(0) },
+          eip1559Tx
+        );
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            amount: new NotEnoughBalance(),
+          })
+        );
+      });
+    });
+
+    describe("Gas", () => {
+      it("should detect missing fees in a 1559 tx and have an error", async () => {
+        const tx = { ...eip1559Tx, maxFeePerGas: undefined };
+        const res = await getTransactionStatus(account, tx as any);
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            gasPrice: new FeeNotLoaded(),
+          })
+        );
+      });
+
+      it("should detect missing fees in a legacy tx and have an error", async () => {
+        const tx = { ...legacyTx, gasPrice: undefined };
+        const res = await getTransactionStatus(account, tx as any);
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            gasPrice: new FeeNotLoaded(),
+          })
+        );
+      });
+
+      it("should detect a gasLimit = 0 in a 1559 tx and have an error", async () => {
+        const tx = { ...eip1559Tx, gasLimit: new BigNumber(0) };
+        const res = await getTransactionStatus(account, tx as any);
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            gasLimit: new FeeNotLoaded(),
+          })
+        );
+      });
+
+      it("should detect a gasLimit = 0 in a legacy tx and have an error", async () => {
+        const tx = { ...legacyTx, gasLimit: new BigNumber(0) };
+        const res = await getTransactionStatus(account, tx as any);
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            gasLimit: new FeeNotLoaded(),
+          })
+        );
+      });
+
+      it("should detect gas limit being too low in a tx and have an error", async () => {
+        const tx = { ...eip1559Tx, gasLimit: new BigNumber(20000) }; // min should be 21000
+        const res = await getTransactionStatus(account, tx);
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            gasLimit: new GasLessThanEstimate(),
+          })
+        );
+      });
+
+      it("should detect gas being too high in a 1559 tx for the account balance and have an error", async () => {
+        const notEnoughBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2099999) },
+          eip1559Tx
+        );
+        const enoughhBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2100000) },
+          eip1559Tx
+        );
+
+        expect(notEnoughBalanceResponse.errors).toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+        expect(enoughhBalanceResponse.errors).not.toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+      });
+
+      it("should detect a maxPriorityFee = 0 in a 1559 tx and have an error", async () => {
+        const res = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2100000) },
+          {
+            ...eip1559Tx,
+            maxPriorityFeePerGas: new BigNumber(0),
+          }
+        );
+
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            maxPriorityFee: new PriorityFeeTooLow(),
+          })
+        );
+      });
+
+      it("should detect gas being too high in a legacy tx for the account balance and have an error", async () => {
+        const notEnoughBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2099999) },
+          legacyTx
+        );
+        const enoughhBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2100001) },
+          legacyTx
+        );
+
+        expect(notEnoughBalanceResponse.errors).toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+        expect(enoughhBalanceResponse.errors).not.toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+      });
+
+      it("should not detect gas being too high in a 1559 tx when there is no recipient and have an error", async () => {
+        const notEnoughBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2099999) },
+          { ...eip1559Tx, recipient: "" }
+        );
+        const enoughhBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2100000) },
+          { ...eip1559Tx, recipient: "" }
+        );
+
+        expect(notEnoughBalanceResponse.errors).not.toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+        expect(enoughhBalanceResponse.errors).not.toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+      });
+
+      it("should not detect gas being too high in a legacy tx when there is no recipient and have an error", async () => {
+        const notEnoughBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2099999) },
+          { ...legacyTx, recipient: "" }
+        );
+        const enoughhBalanceResponse = await getTransactionStatus(
+          { ...account, balance: new BigNumber(2100001) },
+          { ...legacyTx, recipient: "" }
+        );
+
+        expect(notEnoughBalanceResponse.errors).not.toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+        expect(enoughhBalanceResponse.errors).not.toEqual(
+          expect.objectContaining({
+            gasPrice: new NotEnoughGas(),
+          })
+        );
+      });
+    });
+
+    describe("Global return", () => {
+      it("should return the expected informations", async () => {
+        const res = await getTransactionStatus(account, legacyTx);
+
+        expect(res).toEqual(
+          expect.objectContaining({
+            errors: expect.any(Object),
+            warnings: expect.any(Object),
+            estimatedFees: new BigNumber(2100000),
+            amount: legacyTx.amount,
+            totalSpent: new BigNumber(2100000).plus(legacyTx.amount),
+          })
+        );
+      });
+    });
+  });
+});

package/src/__tests__/hw-getAddress.unit.test.ts

@@ -0,0 +1,24 @@
+import eip55 from "eip55";
+import getAddress from "../hw-getAddress";
+
+const address = "0xc3f95102D5c8F2c83e49Ce3Acfb905eDfb7f37dE";
+jest.mock(
+  "@ledgerhq/hw-app-eth",
+  () =>
+    class {
+      getAddress = async () => ({
+        publicKey: "",
+        address: address.toLowerCase(),
+      });
+    }
+);
+
+describe("EVM Family", () => {
+  describe("hw-getAddress.ts", () => {
+    it("should return an eip 55 encoded address", async () => {
+      const response = await getAddress({} as any, {} as any);
+      expect(response.address).toBe(address);
+      expect(eip55.verify(response.address)).toBe(true);
+    });
+  });
+});