@ledgerhq/coin-evm 0.2.0-next.0

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

@@ -0,0 +1,406 @@
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import * as cryptoAssetsTokens from "@ledgerhq/cryptoassets/tokens";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import * as RPC_API from "../api/rpc.common";
+import {
+  eip1559TransactionHasFees,
+  getAdditionalLayer2Fees,
+  getEstimatedFees,
+  getSyncHash,
+  legacyTransactionHasFees,
+  mergeSubAccounts,
+} from "../logic";
+import { makeAccount, makeOperation, makeTokenAccount } from "../testUtils";
+import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../types";
+
+describe("EVM Family", () => {
+  describe("logic.ts", () => {
+    describe("legacyTransactionHasFees", () => {
+      it("should return true for legacy tx with fees", () => {
+        const tx: Partial<EvmTransactionLegacy> = {
+          type: 0,
+          gasPrice: new BigNumber(100),
+        };
+
+        expect(legacyTransactionHasFees(tx as EvmTransactionLegacy)).toBe(true);
+      });
+
+      it("should return true for type 1 (unused in the live for now) tx with fees", () => {
+        const tx: Partial<EvmTransactionLegacy> = {
+          type: 1,
+          gasPrice: new BigNumber(100),
+        };
+
+        expect(legacyTransactionHasFees(tx as EvmTransactionLegacy)).toBe(true);
+      });
+
+      it("should return false for legacy tx without fees", () => {
+        const tx: Partial<EvmTransactionLegacy> = {
+          type: 0,
+        };
+
+        expect(legacyTransactionHasFees(tx as any)).toBe(false);
+      });
+
+      it("should return false for legacy tx with wrong fees", () => {
+        const tx: Partial<EvmTransactionEIP1559> = {
+          type: 2,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+        };
+
+        expect(legacyTransactionHasFees(tx as any)).toBe(false);
+      });
+
+      it("should return true for legacy tx with fees but no type (default being a legacy tx)", () => {
+        const tx: Partial<EvmTransactionLegacy> = {
+          gasPrice: new BigNumber(100),
+        };
+
+        expect(legacyTransactionHasFees(tx as any)).toBe(true);
+      });
+    });
+
+    describe("eip1559TransactionHasFess", () => {
+      it("should return true for 1559 tx with fees", () => {
+        const tx: Partial<EvmTransactionEIP1559> = {
+          type: 2,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+        };
+
+        expect(eip1559TransactionHasFees(tx as any)).toBe(true);
+      });
+
+      it("should return false for 1559 tx without fees", () => {
+        const tx: Partial<EvmTransactionEIP1559> = {
+          type: 2,
+        };
+
+        expect(eip1559TransactionHasFees(tx as any)).toBe(false);
+      });
+
+      it("should return false for 1559 tx with wrong fees", () => {
+        const tx: unknown = {
+          type: 2,
+          gasPrice: new BigNumber(100),
+        };
+
+        expect(eip1559TransactionHasFees(tx as any)).toBe(false);
+      });
+    });
+
+    describe("getEstimatedFees", () => {
+      it("should return the right fee estimation for a legacy tx", () => {
+        const tx = {
+          type: 0,
+          gasLimit: new BigNumber(3),
+          gasPrice: new BigNumber(23),
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(40),
+        };
+
+        expect(getEstimatedFees(tx as any)).toEqual(new BigNumber(69));
+      });
+
+      it("should fallback with tx without type", () => {
+        const tx = {};
+        expect(getEstimatedFees(tx as any)).toEqual(new BigNumber(0));
+      });
+
+      it("should fallback with badly formatted legacy tx", () => {
+        const tx = {
+          type: 0,
+        };
+
+        expect(getEstimatedFees(tx as any)).toEqual(new BigNumber(0));
+      });
+
+      it("should return the right fee estimation for a 1559 tx", () => {
+        const tx = {
+          type: 2,
+          gasLimit: new BigNumber(42),
+          gasPrice: new BigNumber(23),
+          maxFeePerGas: new BigNumber(10),
+          maxPriorityFeePerGas: new BigNumber(40),
+        };
+
+        expect(getEstimatedFees(tx as any)).toEqual(new BigNumber(420));
+      });
+
+      it("should fallback with badly formatted 1559 tx", () => {
+        const tx = {
+          type: 2,
+        };
+
+        expect(getEstimatedFees(tx as any)).toEqual(new BigNumber(0));
+      });
+    });
+
+    describe("getAdditionalLayer2Fees", () => {
+      const optimism = getCryptoCurrencyById("optimism");
+      const ethereum = getCryptoCurrencyById("ethereum");
+
+      beforeEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should try to get additionalFees for a valid layer 2", async () => {
+        const spy = jest
+          .spyOn(RPC_API, "getOptimismAdditionalFees")
+          .mockImplementation(jest.fn());
+
+        await getAdditionalLayer2Fees(optimism, {} as any);
+        expect(spy).toBeCalled();
+      });
+
+      it("should not try to get additionalFees for an invalid layer 2", async () => {
+        const spy = jest
+          .spyOn(RPC_API, "getOptimismAdditionalFees")
+          .mockImplementation(jest.fn());
+
+        await getAdditionalLayer2Fees(ethereum, {} as any);
+        expect(spy).not.toBeCalled();
+      });
+    });
+
+    describe("mergeSubAccounts", () => {
+      it("should merge 2 different sub accounts", () => {
+        const tokenAccount1 = {
+          ...makeTokenAccount(
+            "0xkvn",
+            getTokenById("ethereum/erc20/usd__coin")
+          ),
+          balance: new BigNumber(1),
+          operations: [],
+        };
+        const tokenAccount2 = {
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/weth")),
+          balance: new BigNumber(2),
+          operations: [],
+        };
+        const account = makeAccount(
+          "0xkvn",
+          getCryptoCurrencyById("ethereum"),
+          [tokenAccount1]
+        );
+
+        const newSubAccounts = mergeSubAccounts(account, [tokenAccount2]);
+        expect(newSubAccounts).toEqual([tokenAccount1, tokenAccount2]);
+        expect(newSubAccounts).not.toBe(account.subAccounts); // shouldn't mutate original account
+        expect(account.subAccounts).toEqual([tokenAccount1]); // shouldn't mutate original account
+        expect(newSubAccounts[0]).toBe(account.subAccounts?.[0]); // keeping the reference though
+      });
+
+      it("should merge 2 different sub accounts and update the first one", () => {
+        const tokenAccount1 = {
+          ...makeTokenAccount(
+            "0xkvn",
+            getTokenById("ethereum/erc20/usd__coin")
+          ),
+          balance: new BigNumber(1),
+          operations: [],
+        };
+        const tokenAccount1Bis = {
+          ...tokenAccount1,
+          balance: new BigNumber(10),
+          spendableBalance: new BigNumber(11),
+          operationsCount: 0,
+          balanceHistoryCache: {
+            HOUR: {
+              latestDate: 123,
+              balances: [123],
+            },
+            DAY: {
+              latestDate: 234,
+              balances: [234],
+            },
+            WEEK: {
+              latestDate: 345,
+              balances: [345],
+            },
+          },
+          operations: [],
+        };
+        const tokenAccount2 = {
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/weth")),
+          balance: new BigNumber(2),
+          operations: [],
+        };
+        const account = makeAccount(
+          "0xkvn",
+          getCryptoCurrencyById("ethereum"),
+          [tokenAccount1]
+        );
+
+        const newSubAccounts = mergeSubAccounts(account, [
+          tokenAccount1Bis,
+          tokenAccount2,
+        ]);
+        expect(newSubAccounts).toEqual([tokenAccount1Bis, tokenAccount2]);
+        expect(newSubAccounts).not.toBe(account.subAccounts); // shouldn't mutate original account
+        expect(account.subAccounts).toEqual([tokenAccount1]); // shouldn't mutate original account
+        expect(newSubAccounts[0]).not.toBe(account.subAccounts?.[0]); // changing the ref as a change happened in tokenAccount1
+      });
+
+      it("should update subAccount ops", () => {
+        const op1 = makeOperation();
+        const op2 = makeOperation({
+          hash: "0xdiffHash",
+        });
+        const op3 = makeOperation({
+          hash: "0xAgAinAnotHeRH4sh",
+        });
+        const tokenAccount1 = {
+          ...makeTokenAccount(
+            "0xkvn",
+            getTokenById("ethereum/erc20/usd__coin")
+          ),
+          balance: new BigNumber(1),
+          operations: [op1, op2],
+          operationsCount: 2,
+        };
+        const tokenAccount1Bis = {
+          ...tokenAccount1,
+          operations: [op3, op1, op2],
+          operationsCount: 3,
+        };
+        const account = makeAccount(
+          "0xkvn",
+          getCryptoCurrencyById("ethereum"),
+          [tokenAccount1]
+        );
+
+        const newSubAccounts = mergeSubAccounts(account, [tokenAccount1Bis]);
+        expect(newSubAccounts).not.toBe(account.subAccounts); // shouldn't mutate original account
+        expect(account.subAccounts).toEqual([tokenAccount1]); // shouldn't mutate original account
+        expect(newSubAccounts[0]).not.toBe(account.subAccounts?.[0]); // changing the ref as change happened
+        expect(newSubAccounts[0]?.operations?.[1]).toBe(
+          account.subAccounts?.[0]?.operations?.[0]
+        ); // keeping the reference for the ops though
+        expect(newSubAccounts[0]?.operations?.[2]).toBe(
+          account.subAccounts?.[0]?.operations?.[1]
+        ); // keeping the reference for the ops though
+        expect(newSubAccounts).toEqual([tokenAccount1Bis]);
+      });
+
+      it("should return only new sub accounts", () => {
+        const tokenAccount = {
+          ...makeTokenAccount(
+            "0xkvn",
+            getTokenById("ethereum/erc20/usd__coin")
+          ),
+          balance: new BigNumber(1),
+        };
+        const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"));
+        delete account.subAccounts;
+
+        const newSubAccounts = mergeSubAccounts(account, [tokenAccount]);
+        expect(newSubAccounts).toEqual([tokenAccount]);
+        expect(account.subAccounts).toBe(undefined); // shouldn't mutate original account
+      });
+
+      it("should dedup sub accounts", () => {
+        const tokenAccount = {
+          ...makeTokenAccount(
+            "0xkvn",
+            getTokenById("ethereum/erc20/usd__coin")
+          ),
+          balance: new BigNumber(1),
+        };
+        const account = makeAccount(
+          "0xkvn",
+          getCryptoCurrencyById("ethereum"),
+          [tokenAccount]
+        );
+
+        const newSubAccounts = mergeSubAccounts(account, [
+          tokenAccount,
+          { ...tokenAccount },
+          { ...tokenAccount },
+        ]);
+        expect(newSubAccounts).toEqual([tokenAccount]);
+      });
+    });
+
+    describe("getSyncHash", () => {
+      const currency = getCryptoCurrencyById("ethereum");
+
+      afterEach(() => {
+        jest.restoreAllMocks();
+      });
+
+      it("should provide a valid sha256 hash", () => {
+        expect(getSyncHash(currency)).toStrictEqual(
+          expect.stringMatching(/^0x[A-Fa-f0-9]{64}$/)
+        );
+      });
+
+      it("should provide a hash not dependent on reference", () => {
+        jest
+          .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
+          .mockImplementationOnce((currency): TokenCurrency[] => {
+            const { listTokensForCryptoCurrency } = jest.requireActual(
+              "@ledgerhq/cryptoassets/tokens"
+            );
+            return listTokensForCryptoCurrency(currency).map(
+              (t: TokenCurrency) => ({ ...t })
+            );
+          });
+        expect(getSyncHash(currency)).toEqual(getSyncHash(currency));
+      });
+
+      it("should provide a new hash if a token is removed", () => {
+        jest
+          .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
+          .mockImplementationOnce((currency) => {
+            const { listTokensForCryptoCurrency } = jest.requireActual(
+              "@ledgerhq/cryptoassets/tokens"
+            );
+            const list: TokenCurrency[] = listTokensForCryptoCurrency(currency);
+            return list.slice(0, list.length - 2);
+          });
+        expect(getSyncHash(currency)).not.toEqual(getSyncHash(currency));
+      });
+
+      it("should provide a new hash if a token is modified", () => {
+        jest
+          .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
+          .mockImplementationOnce((currency) => {
+            const { listTokensForCryptoCurrency } = jest.requireActual(
+              "@ledgerhq/cryptoassets/tokens"
+            );
+            const [first, ...rest]: TokenCurrency[] =
+              listTokensForCryptoCurrency(currency);
+            const modifedFirst = { ...first, delisted: !first.delisted };
+            return [modifedFirst, ...rest];
+          });
+
+        expect(getSyncHash(currency)).not.toEqual(getSyncHash(currency));
+      });
+
+      it("should provide a new hash if a token is added", () => {
+        jest
+          .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
+          .mockImplementationOnce((currency) => {
+            const { listTokensForCryptoCurrency } = jest.requireActual(
+              "@ledgerhq/cryptoassets/tokens"
+            );
+            return [
+              ...listTokensForCryptoCurrency(currency),
+              {
+                type: "TokenCurrency",
+                id: "test",
+                ledgerSignature: "string",
+                contractAddress: "0x123",
+                parentCurrency: currency,
+                tokenType: "erc20",
+              } as TokenCurrency,
+            ];
+          });
+        expect(getSyncHash(currency)).not.toEqual(getSyncHash(currency));
+      });
+    });
+  });
+});

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

@@ -0,0 +1,139 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import evms from "@ledgerhq/cryptoassets/data/evm/index";
+import * as CALTokensAPI from "@ledgerhq/cryptoassets/tokens";
+import { ERC20Token } from "@ledgerhq/cryptoassets/types";
+import network from "@ledgerhq/live-network/network";
+import { fetchERC20Tokens, hydrate, preload } from "../preload";
+
+const usdcDefinition: ERC20Token = [
+  "ethereum",
+  "usd__coin",
+  "USDC",
+  6,
+  "USD Coin",
+  "3045022100b2e358726e4e6a6752cf344017c0e9d45b9a904120758d45f61b2804f9ad5299022015161ef28d8c4481bd9432c13562def9cce688bcfec896ef244c9a213f106cdd",
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  false,
+  false,
+  undefined,
+  undefined,
+];
+const usdtDefinition: ERC20Token = [
+  "ethereum",
+  "usd_tether__erc20_",
+  "USDT",
+  6,
+  "Tether USD",
+  "3044022078c66ccea3e4dedb15a24ec3c783d7b582cd260daf62fd36afe9a8212a344aed0220160ba8c1c4b6a8aa6565bed20632a091aeeeb7bfdac67fc6589a6031acbf511c",
+  "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  false,
+  false,
+  undefined,
+  undefined,
+];
+const currency1 = getCryptoCurrencyById("ethereum"); // chain id 1
+
+jest.mock("@ledgerhq/live-network/network");
+jest.mock("@ledgerhq/cryptoassets/data/evm/index", () => ({
+  get tokens() {
+    return {
+      1: [usdcDefinition],
+    };
+  },
+}));
+
+describe("EVM Family", () => {
+  beforeEach(() => {
+    // @ts-expect-error not casted as jest mock
+    network.mockResolvedValue({});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("preload.ts", () => {
+    describe("fetchERC20Tokens", () => {
+      it("should load dynamically the tokens", async () => {
+        // @ts-expect-error not casted as jest mock
+        network.mockResolvedValue({ data: [usdtDefinition] });
+
+        const tokens = await fetchERC20Tokens(currency1);
+        expect(tokens).toEqual([usdtDefinition]);
+      });
+
+      it("should fallback on local CAL on dynamic CAL error", async () => {
+        // @ts-expect-error not casted as jest mock
+        network.mockImplementationOnce(async () => {
+          throw new Error();
+        });
+
+        const tokens = await fetchERC20Tokens(currency1);
+        expect(tokens).toEqual([usdcDefinition]);
+      });
+
+      it("should load erc20 tokens from local CAL when dynamic CAL undefined", async () => {
+        const tokens = await fetchERC20Tokens(currency1);
+        expect(tokens).toEqual([usdcDefinition]);
+      });
+
+      it("should load erc20 tokens from local CAL when dynamic CAL is empty []", async () => {
+        // @ts-expect-error not casted as jest mock
+        network.mockResolvedValue({
+          data: {
+            tokens: { 1: [] },
+          },
+        });
+
+        const tokens = await fetchERC20Tokens(currency1);
+        expect(tokens).toEqual([usdcDefinition]);
+      });
+
+      it("should return empty [] if dynamic CAL fails and local CAL fails", async () => {
+        jest
+          .spyOn(evms, "tokens", "get")
+          .mockImplementationOnce(() => ({} as any));
+
+        const tokens = await fetchERC20Tokens(currency1);
+        expect(tokens).toEqual([]);
+      });
+    });
+
+    describe("preload", () => {
+      it("should register tokens", async () => {
+        jest
+          .spyOn(CALTokensAPI, "addTokens")
+          .mockImplementationOnce(() => null);
+
+        const tokens = await preload(currency1);
+
+        expect(tokens).toEqual([usdcDefinition]);
+        expect(CALTokensAPI.addTokens).toHaveBeenCalledWith([
+          CALTokensAPI.convertERC20(usdcDefinition),
+        ]);
+      });
+    });
+
+    describe("hydrate", () => {
+      afterEach(() => {
+        jest.restoreAllMocks();
+      });
+
+      it("should return void", () => {
+        expect(hydrate(undefined)).toBe(undefined);
+      });
+
+      it("should register tokens", async () => {
+        jest
+          .spyOn(CALTokensAPI, "addTokens")
+          .mockImplementationOnce(() => null);
+
+        await hydrate([usdcDefinition]);
+
+        expect(CALTokensAPI.addTokens).toHaveBeenCalledWith([
+          CALTokensAPI.convertERC20(usdcDefinition),
+        ]);
+      });
+    });
+  });
+});