@ledgerhq/coin-evm 0.2.1 → 0.2.2-nightly.0

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

@@ -18,13 +18,8 @@ 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 tokenAccount = makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin"));
+const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"), [tokenAccount]);
 const legacyTx: EvmTransactionLegacy = {
   amount: new BigNumber(100),
   useAllAmount: false,
@@ -66,7 +61,7 @@ describe("EVM Family", () => {
         expect(res.errors).toEqual(
           expect.objectContaining({
             recipient: new RecipientRequired(),
-          })
+          }),
         );
       });
 
@@ -78,7 +73,7 @@ describe("EVM Family", () => {
             recipient: new InvalidAddress("", {
               currency: account.currency,
             }),
-          })
+          }),
         );
       });
 
@@ -93,7 +88,7 @@ describe("EVM Family", () => {
             recipient: new InvalidAddress("", {
               currency: account.currency,
             }),
-          })
+          }),
         );
       });
 
@@ -103,7 +98,7 @@ describe("EVM Family", () => {
         expect(res.warnings).toEqual(
           expect.objectContaining({
             recipient: new ETHAddressNonEIP(),
-          })
+          }),
         );
       });
     });
@@ -120,7 +115,7 @@ describe("EVM Family", () => {
         expect(res.errors).toEqual(
           expect.objectContaining({
             amount: new AmountRequired(),
-          })
+          }),
         );
       });
 
@@ -131,7 +126,7 @@ describe("EVM Family", () => {
         };
         const res = await getTransactionStatus(
           { ...account, balance: new BigNumber(10000000) },
-          tx
+          tx,
         );
 
         expect(res.errors).toEqual({});
@@ -155,7 +150,7 @@ describe("EVM Family", () => {
               },
             ],
           },
-          tx
+          tx,
         );
 
         expect(res.errors).toEqual({});
@@ -164,13 +159,13 @@ describe("EVM Family", () => {
       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
+          eip1559Tx,
         );
 
         expect(res.errors).toEqual(
           expect.objectContaining({
             amount: new NotEnoughBalance(),
-          })
+          }),
         );
       });
     });
@@ -183,7 +178,7 @@ describe("EVM Family", () => {
         expect(res.errors).toEqual(
           expect.objectContaining({
             gasPrice: new FeeNotLoaded(),
-          })
+          }),
         );
       });
 
@@ -194,7 +189,7 @@ describe("EVM Family", () => {
         expect(res.errors).toEqual(
           expect.objectContaining({
             gasPrice: new FeeNotLoaded(),
-          })
+          }),
         );
       });
 
@@ -205,7 +200,7 @@ describe("EVM Family", () => {
         expect(res.errors).toEqual(
           expect.objectContaining({
             gasLimit: new FeeNotLoaded(),
-          })
+          }),
         );
       });
 
@@ -216,7 +211,7 @@ describe("EVM Family", () => {
         expect(res.errors).toEqual(
           expect.objectContaining({
             gasLimit: new FeeNotLoaded(),
-          })
+          }),
         );
       });
 
@@ -227,29 +222,29 @@ describe("EVM Family", () => {
         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
+          eip1559Tx,
         );
         const enoughhBalanceResponse = await getTransactionStatus(
           { ...account, balance: new BigNumber(2100000) },
-          eip1559Tx
+          eip1559Tx,
         );
 
         expect(notEnoughBalanceResponse.errors).toEqual(
           expect.objectContaining({
             gasPrice: new NotEnoughGas(),
-          })
+          }),
         );
         expect(enoughhBalanceResponse.errors).not.toEqual(
           expect.objectContaining({
             gasPrice: new NotEnoughGas(),
-          })
+          }),
         );
       });
 
@@ -259,79 +254,79 @@ describe("EVM Family", () => {
           {
             ...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
+          legacyTx,
         );
         const enoughhBalanceResponse = await getTransactionStatus(
           { ...account, balance: new BigNumber(2100001) },
-          legacyTx
+          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: "" }
+          { ...eip1559Tx, recipient: "" },
         );
         const enoughhBalanceResponse = await getTransactionStatus(
           { ...account, balance: new BigNumber(2100000) },
-          { ...eip1559Tx, recipient: "" }
+          { ...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: "" }
+          { ...legacyTx, recipient: "" },
         );
         const enoughhBalanceResponse = await getTransactionStatus(
           { ...account, balance: new BigNumber(2100001) },
-          { ...legacyTx, recipient: "" }
+          { ...legacyTx, recipient: "" },
         );
 
         expect(notEnoughBalanceResponse.errors).not.toEqual(
           expect.objectContaining({
             gasPrice: new NotEnoughGas(),
-          })
+          }),
         );
         expect(enoughhBalanceResponse.errors).not.toEqual(
           expect.objectContaining({
             gasPrice: new NotEnoughGas(),
-          })
+          }),
         );
       });
     });
@@ -347,7 +342,7 @@ describe("EVM Family", () => {
             estimatedFees: new BigNumber(2100000),
             amount: legacyTx.amount,
             totalSpent: new BigNumber(2100000).plus(legacyTx.amount),
-          })
+          }),
         );
       });
     });

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

@@ -1,5 +1,6 @@
 import eip55 from "eip55";
-import getAddress from "../hw-getAddress";
+import resolver from "../hw-getAddress";
+import { EvmAddress, EvmSignature, EvmSigner } from "../signer";
 
 const address = "0xc3f95102D5c8F2c83e49Ce3Acfb905eDfb7f37dE";
 jest.mock(
@@ -10,12 +11,24 @@ jest.mock(
         publicKey: "",
         address: address.toLowerCase(),
       });
-    }
+    },
 );
+const mockSignerFactory = (
+  _: string,
+  fn: (signer: EvmSigner) => Promise<EvmAddress | EvmSignature>,
+) =>
+  fn({
+    getAddress: async () => ({
+      publicKey: "",
+      address: address.toLowerCase(),
+    }),
+    signTransaction: jest.fn(),
+  });
 
 describe("EVM Family", () => {
   describe("hw-getAddress.ts", () => {
     it("should return an eip 55 encoded address", async () => {
+      const getAddress = resolver(mockSignerFactory);
       const response = await getAddress({} as any, {} as any);
       expect(response.address).toBe(address);
       expect(eip55.verify(response.address)).toBe(true);

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

@@ -2,7 +2,7 @@ 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 * as RPC_API from "../api/rpc/rpc.common";
 import {
   eip1559TransactionHasFees,
   getAdditionalLayer2Fees,
@@ -147,18 +147,14 @@ describe("EVM Family", () => {
       });
 
       it("should try to get additionalFees for a valid layer 2", async () => {
-        const spy = jest
-          .spyOn(RPC_API, "getOptimismAdditionalFees")
-          .mockImplementation(jest.fn());
+        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());
+        const spy = jest.spyOn(RPC_API, "getOptimismAdditionalFees").mockImplementation(jest.fn());
 
         await getAdditionalLayer2Fees(ethereum, {} as any);
         expect(spy).not.toBeCalled();
@@ -168,10 +164,7 @@ describe("EVM Family", () => {
     describe("mergeSubAccounts", () => {
       it("should merge 2 different sub accounts", () => {
         const tokenAccount1 = {
-          ...makeTokenAccount(
-            "0xkvn",
-            getTokenById("ethereum/erc20/usd__coin")
-          ),
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
           balance: new BigNumber(1),
           operations: [],
         };
@@ -180,11 +173,7 @@ describe("EVM Family", () => {
           balance: new BigNumber(2),
           operations: [],
         };
-        const account = makeAccount(
-          "0xkvn",
-          getCryptoCurrencyById("ethereum"),
-          [tokenAccount1]
-        );
+        const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"), [tokenAccount1]);
 
         const newSubAccounts = mergeSubAccounts(account, [tokenAccount2]);
         expect(newSubAccounts).toEqual([tokenAccount1, tokenAccount2]);
@@ -195,10 +184,7 @@ describe("EVM Family", () => {
 
       it("should merge 2 different sub accounts and update the first one", () => {
         const tokenAccount1 = {
-          ...makeTokenAccount(
-            "0xkvn",
-            getTokenById("ethereum/erc20/usd__coin")
-          ),
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
           balance: new BigNumber(1),
           operations: [],
         };
@@ -228,16 +214,9 @@ describe("EVM Family", () => {
           balance: new BigNumber(2),
           operations: [],
         };
-        const account = makeAccount(
-          "0xkvn",
-          getCryptoCurrencyById("ethereum"),
-          [tokenAccount1]
-        );
+        const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"), [tokenAccount1]);
 
-        const newSubAccounts = mergeSubAccounts(account, [
-          tokenAccount1Bis,
-          tokenAccount2,
-        ]);
+        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
@@ -253,10 +232,7 @@ describe("EVM Family", () => {
           hash: "0xAgAinAnotHeRH4sh",
         });
         const tokenAccount1 = {
-          ...makeTokenAccount(
-            "0xkvn",
-            getTokenById("ethereum/erc20/usd__coin")
-          ),
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
           balance: new BigNumber(1),
           operations: [op1, op2],
           operationsCount: 2,
@@ -266,31 +242,20 @@ describe("EVM Family", () => {
           operations: [op3, op1, op2],
           operationsCount: 3,
         };
-        const account = makeAccount(
-          "0xkvn",
-          getCryptoCurrencyById("ethereum"),
-          [tokenAccount1]
-        );
+        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[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")
-          ),
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
           balance: new BigNumber(1),
         };
         const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"));
@@ -303,17 +268,10 @@ describe("EVM Family", () => {
 
       it("should dedup sub accounts", () => {
         const tokenAccount = {
-          ...makeTokenAccount(
-            "0xkvn",
-            getTokenById("ethereum/erc20/usd__coin")
-          ),
+          ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
           balance: new BigNumber(1),
         };
-        const account = makeAccount(
-          "0xkvn",
-          getCryptoCurrencyById("ethereum"),
-          [tokenAccount]
-        );
+        const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"), [tokenAccount]);
 
         const newSubAccounts = mergeSubAccounts(account, [
           tokenAccount,
@@ -332,9 +290,7 @@ describe("EVM Family", () => {
       });
 
       it("should provide a valid sha256 hash", () => {
-        expect(getSyncHash(currency)).toStrictEqual(
-          expect.stringMatching(/^0x[A-Fa-f0-9]{64}$/)
-        );
+        expect(getSyncHash(currency)).toStrictEqual(expect.stringMatching(/^0x[A-Fa-f0-9]{64}$/));
       });
 
       it("should provide a hash not dependent on reference", () => {
@@ -342,11 +298,9 @@ describe("EVM Family", () => {
           .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
           .mockImplementationOnce((currency): TokenCurrency[] => {
             const { listTokensForCryptoCurrency } = jest.requireActual(
-              "@ledgerhq/cryptoassets/tokens"
-            );
-            return listTokensForCryptoCurrency(currency).map(
-              (t: TokenCurrency) => ({ ...t })
+              "@ledgerhq/cryptoassets/tokens",
             );
+            return listTokensForCryptoCurrency(currency).map((t: TokenCurrency) => ({ ...t }));
           });
         expect(getSyncHash(currency)).toEqual(getSyncHash(currency));
       });
@@ -354,9 +308,9 @@ describe("EVM Family", () => {
       it("should provide a new hash if a token is removed", () => {
         jest
           .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
-          .mockImplementationOnce((currency) => {
+          .mockImplementationOnce(currency => {
             const { listTokensForCryptoCurrency } = jest.requireActual(
-              "@ledgerhq/cryptoassets/tokens"
+              "@ledgerhq/cryptoassets/tokens",
             );
             const list: TokenCurrency[] = listTokensForCryptoCurrency(currency);
             return list.slice(0, list.length - 2);
@@ -367,12 +321,11 @@ describe("EVM Family", () => {
       it("should provide a new hash if a token is modified", () => {
         jest
           .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
-          .mockImplementationOnce((currency) => {
+          .mockImplementationOnce(currency => {
             const { listTokensForCryptoCurrency } = jest.requireActual(
-              "@ledgerhq/cryptoassets/tokens"
+              "@ledgerhq/cryptoassets/tokens",
             );
-            const [first, ...rest]: TokenCurrency[] =
-              listTokensForCryptoCurrency(currency);
+            const [first, ...rest]: TokenCurrency[] = listTokensForCryptoCurrency(currency);
             const modifedFirst = { ...first, delisted: !first.delisted };
             return [modifedFirst, ...rest];
           });
@@ -383,9 +336,9 @@ describe("EVM Family", () => {
       it("should provide a new hash if a token is added", () => {
         jest
           .spyOn(cryptoAssetsTokens, "listTokensForCryptoCurrency")
-          .mockImplementationOnce((currency) => {
+          .mockImplementationOnce(currency => {
             const { listTokensForCryptoCurrency } = jest.requireActual(
-              "@ledgerhq/cryptoassets/tokens"
+              "@ledgerhq/cryptoassets/tokens",
             );
             return [
               ...listTokensForCryptoCurrency(currency),

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

@@ -90,9 +90,7 @@ describe("EVM Family", () => {
       });
 
       it("should return empty [] if dynamic CAL fails and local CAL fails", async () => {
-        jest
-          .spyOn(evms, "tokens", "get")
-          .mockImplementationOnce(() => ({} as any));
+        jest.spyOn(evms, "tokens", "get").mockImplementationOnce(() => ({} as any));
 
         const tokens = await fetchERC20Tokens(currency1);
         expect(tokens).toEqual([]);
@@ -101,9 +99,7 @@ describe("EVM Family", () => {
 
     describe("preload", () => {
       it("should register tokens", async () => {
-        jest
-          .spyOn(CALTokensAPI, "addTokens")
-          .mockImplementationOnce(() => null);
+        jest.spyOn(CALTokensAPI, "addTokens").mockImplementationOnce(() => null);
 
         const tokens = await preload(currency1);
 
@@ -124,9 +120,7 @@ describe("EVM Family", () => {
       });
 
       it("should register tokens", async () => {
-        jest
-          .spyOn(CALTokensAPI, "addTokens")
-          .mockImplementationOnce(() => null);
+        jest.spyOn(CALTokensAPI, "addTokens").mockImplementationOnce(() => null);
 
         await hydrate([usdcDefinition]);