@ledgerhq/coin-evm 0.3.0 → 0.4.0-next.0

package/src/__tests__/{prepareTransaction.unit.test.ts → unit/prepareTransaction.unit.test.ts}

@@ -1,39 +1,16 @@
-import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
 import BigNumber from "bignumber.js";
-import { ethers } from "ethers";
-import ERC20ABI from "../abis/erc20.abi.json";
-import * as rpcAPI from "../api/rpc/rpc.common";
-import { prepareForSignOperation, prepareTransaction } from "../prepareTransaction";
-import { makeAccount, makeTokenAccount } from "../testUtils";
-import { Transaction as EvmTransaction, GasOptions } from "../types";
-
-const currency = getCryptoCurrencyById("ethereum");
-const tokenAccount = makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin"));
-const account = makeAccount("0xkvn", currency, [tokenAccount]);
-const transaction: EvmTransaction = {
-  amount: new BigNumber(100),
-  useAllAmount: false,
-  subAccountId: "id",
-  recipient: "0x6bfD74C0996F269Bcece59191EFf667b3dFD73b9",
-  feesStrategy: "medium",
-  family: "evm",
-  mode: "send",
-  gasPrice: new BigNumber(0),
-  gasLimit: new BigNumber(21000),
-  nonce: 0,
-  chainId: 1,
-};
-const tokenTransaction: EvmTransaction = {
-  ...transaction,
-  subAccountId: tokenAccount.id,
-};
-const expectedData = (recipient: string, amount: BigNumber): Buffer =>
-  Buffer.from(
-    new ethers.utils.Interface(ERC20ABI)
-      .encodeFunctionData("transfer", [recipient, amount.toFixed()])
-      .slice(2),
-    "hex",
-  );
+import { prepareForSignOperation, prepareTransaction } from "../../prepareTransaction";
+import * as rpcAPI from "../../api/rpc/rpc.common";
+import {
+  account,
+  expectedData,
+  nftTransaction,
+  tokenAccount,
+  tokenTransaction,
+  transaction,
+} from "../fixtures/prepareTransaction.fixtures";
+import { GasOptions } from "../../types";
+import * as nftAPI from "../../api/nft";
 
 describe("EVM Family", () => {
   describe("prepareTransaction.ts", () => {
@@ -46,6 +23,23 @@ describe("EVM Family", () => {
         maxFeePerGas: new BigNumber(1),
         maxPriorityFeePerGas: new BigNumber(1),
       }));
+      jest.spyOn(nftAPI, "getNftCollectionMetadata").mockImplementation(async input => {
+        if (
+          input[0]?.contract === "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D" &&
+          input.length === 1
+        ) {
+          return [
+            {
+              status: 200,
+              result: {
+                contract: "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D",
+                tokenName: "Bored Ape",
+              },
+            },
+          ];
+        }
+        return [];
+      });
     });
 
     afterEach(() => {
@@ -53,6 +47,13 @@ describe("EVM Family", () => {
     });
 
     describe("prepareTransaction", () => {
+      it("should preserve the reference when no change is detected on the transaction", async () => {
+        const tx = await prepareTransaction(account, { ...transaction });
+        const tx2 = await prepareTransaction(account, tx);
+
+        expect(tx).toBe(tx2);
+      });
+
       describe("Coins", () => {
         it("should have a gasLimit = 0 when recipient has an error", async () => {
           jest.spyOn(rpcAPI, "getGasEstimation").mockImplementation(async () => {
@@ -97,10 +98,11 @@ describe("EVM Family", () => {
         });
 
         it("should return an EIP1559 coin transaction", async () => {
-          const tx = await prepareTransaction(account, transaction);
+          const tx = await prepareTransaction(account, { ...transaction });
 
           expect(tx).toEqual({
             ...transaction,
+            gasPrice: undefined,
             maxFeePerGas: new BigNumber(1),
             maxPriorityFeePerGas: new BigNumber(1),
             type: 2,
@@ -114,11 +116,13 @@ describe("EVM Family", () => {
             maxPriorityFeePerGas: null,
           }));
 
-          const tx = await prepareTransaction(account, transaction);
+          const tx = await prepareTransaction(account, { ...transaction });
 
           expect(tx).toEqual({
             ...transaction,
             gasPrice: new BigNumber(1),
+            maxFeePerGas: undefined,
+            maxPriorityFeePerGas: undefined,
             type: 0,
           });
         });
@@ -133,12 +137,15 @@ describe("EVM Family", () => {
             useAllAmount: true,
           };
 
-          const tx = await prepareTransaction(accountWithBalance, transactionWithUseAllAmount);
+          const tx = await prepareTransaction(accountWithBalance, {
+            ...transactionWithUseAllAmount,
+          });
           const estimatedFees = new BigNumber(21000); // 21000 gasLimit * 1 maxFeePerGas
 
           expect(tx).toEqual({
             ...transactionWithUseAllAmount,
             amount: accountWithBalance.balance.minus(estimatedFees),
+            gasPrice: undefined,
             maxFeePerGas: new BigNumber(1),
             maxPriorityFeePerGas: new BigNumber(1),
             type: 2,
@@ -162,6 +169,7 @@ describe("EVM Family", () => {
           expect(tx).toEqual({
             ...transaction,
             data: Buffer.from("Sm4rTC0ntr4ct", "hex"),
+            gasPrice: undefined,
             maxFeePerGas: new BigNumber(1),
             maxPriorityFeePerGas: new BigNumber(1),
             gasLimit: new BigNumber(12),
@@ -210,7 +218,7 @@ describe("EVM Family", () => {
             maxPriorityFeePerGas: new BigNumber(1),
             gasPrice: undefined,
             gasLimit: new BigNumber(0),
-            data: expectedData(tokenTransaction.recipient, new BigNumber(0)),
+            data: expectedData(account, tx, "erc20"),
             type: 2,
           });
         });
@@ -241,7 +249,7 @@ describe("EVM Family", () => {
             amount: tokenAccountWithBalance.balance,
             useAllAmount: true,
             subAccountId: tokenAccountWithBalance.id,
-            data: expectedData(tokenTransaction.recipient, tokenAccountWithBalance.balance),
+            data: expectedData(account, tx, "erc20"),
             maxFeePerGas: new BigNumber(1),
             maxPriorityFeePerGas: new BigNumber(1),
             gasPrice: undefined,
@@ -264,7 +272,7 @@ describe("EVM Family", () => {
             subAccounts: [tokenAccountWithBalance],
           };
 
-          await prepareTransaction(account2, {
+          const tx = await prepareTransaction(account2, {
             ...tokenTransaction,
             useAllAmount: true,
             subAccountId: tokenAccountWithBalance.id,
@@ -275,7 +283,7 @@ describe("EVM Family", () => {
             expect.objectContaining({
               recipient: tokenAccount.token.contractAddress,
               amount: new BigNumber(0),
-              data: expectedData(tokenTransaction.recipient, tokenAccountWithBalance.balance),
+              data: expectedData(account, tx, "erc20"),
             }),
           );
         });
@@ -289,11 +297,14 @@ describe("EVM Family", () => {
             ...account,
             subAccounts: [tokenAccountWithBalance],
           };
-          const tx = await prepareTransaction(account2, tokenTransaction);
+          const tx = await prepareTransaction(account2, {
+            ...tokenTransaction,
+          });
 
           expect(tx).toEqual({
             ...tokenTransaction,
-            data: expectedData(tokenTransaction.recipient, tokenTransaction.amount),
+            data: expectedData(account, tokenTransaction, "erc20"),
+            gasPrice: undefined,
             maxFeePerGas: new BigNumber(1),
             maxPriorityFeePerGas: new BigNumber(1),
             type: 2,
@@ -315,107 +326,262 @@ describe("EVM Family", () => {
             ...account,
             subAccounts: [tokenAccountWithBalance],
           };
-          const tx = await prepareTransaction(account2, tokenTransaction);
+          const tx = await prepareTransaction(account2, {
+            ...tokenTransaction,
+          });
 
           expect(tx).toEqual({
             ...tokenTransaction,
-            data: expectedData(tokenTransaction.recipient, tokenTransaction.amount),
+            data: expectedData(account, tokenTransaction, "erc20"),
+            maxFeePerGas: undefined,
+            maxPriorityFeePerGas: undefined,
             gasPrice: new BigNumber(1),
             type: 0,
           });
         });
       });
 
-      describe("When feesStrategy provided", () => {
-        it("should call getFeesEstimation once", async () => {
-          const tx = await prepareTransaction(account, {
-            ...transaction,
-            feesStrategy: undefined,
+      describe("Gas", () => {
+        describe("When feesStrategy provided", () => {
+          it("should call getFeesEstimation once", async () => {
+            const tx = await prepareTransaction(account, {
+              ...transaction,
+              feesStrategy: undefined,
+            });
+
+            expect(rpcAPI.getFeesEstimation).toBeCalledTimes(1);
+
+            expect(tx).toEqual({
+              ...transaction,
+              feesStrategy: undefined,
+              additionalFees: undefined,
+              gasPrice: undefined,
+              maxFeePerGas: new BigNumber(1),
+              maxPriorityFeePerGas: new BigNumber(1),
+              type: 2,
+            });
           });
+        });
 
-          expect(rpcAPI.getFeesEstimation).toBeCalledTimes(1);
+        describe("When custom feesStrategy provided", () => {
+          it("should use transaction provided data for fees", async () => {
+            const tx = await prepareTransaction(account, {
+              ...transaction,
+              feesStrategy: "custom",
+            });
+
+            expect(rpcAPI.getFeesEstimation).toBeCalledTimes(0);
+
+            expect(tx).toEqual({
+              ...transaction,
+              additionalFees: undefined,
+              feesStrategy: "custom",
+              gasPrice: new BigNumber(0),
+              type: 0,
+            });
+          });
+        });
 
-          expect(tx).toEqual({
-            ...transaction,
-            feesStrategy: undefined,
-            additionalFees: undefined,
-            maxFeePerGas: new BigNumber(1),
-            maxPriorityFeePerGas: new BigNumber(1),
-            type: 2,
+        describe("When gasOptions provided", () => {
+          it("should call getFeesEstimation once", async () => {
+            const tx = await prepareTransaction(account, {
+              ...transaction,
+              gasOptions: undefined,
+            });
+
+            expect(rpcAPI.getFeesEstimation).toBeCalledTimes(1);
+
+            expect(tx).toEqual({
+              ...transaction,
+              gasPrice: undefined,
+              maxFeePerGas: new BigNumber(1),
+              maxPriorityFeePerGas: new BigNumber(1),
+              type: 2,
+            });
+          });
+
+          it("should use gasOptions values for fee data", async () => {
+            const gasOptions: GasOptions = {
+              slow: {
+                maxFeePerGas: new BigNumber(10),
+                maxPriorityFeePerGas: new BigNumber(1),
+                gasPrice: null,
+              },
+              medium: {
+                maxFeePerGas: new BigNumber(20),
+                maxPriorityFeePerGas: new BigNumber(2),
+                gasPrice: null,
+              },
+              fast: {
+                maxFeePerGas: new BigNumber(30),
+                maxPriorityFeePerGas: new BigNumber(3),
+                gasPrice: null,
+              },
+            };
+            const tx = await prepareTransaction(account, {
+              ...transaction,
+              gasOptions,
+            });
+
+            expect(rpcAPI.getFeesEstimation).toBeCalledTimes(0);
+
+            expect(tx).toEqual({
+              ...transaction,
+              additionalFees: undefined,
+              gasPrice: undefined,
+              gasOptions,
+              maxFeePerGas: new BigNumber(20),
+              maxPriorityFeePerGas: new BigNumber(2),
+              type: 2,
+            });
           });
         });
       });
 
-      describe("When custom feesStrategy provided", () => {
-        it("should use transaction provided data for fees", async () => {
-          const tx = await prepareTransaction(account, {
-            ...transaction,
-            feesStrategy: "custom",
+      describe("Nfts", () => {
+        it("should have a gasLimit = 0 and no data when recipient has an error", async () => {
+          jest.spyOn(rpcAPI, "getGasEstimation").mockImplementation(async () => {
+            throw new Error();
           });
 
-          expect(rpcAPI.getFeesEstimation).toBeCalledTimes(0);
+          const tx = await prepareTransaction(account, {
+            ...nftTransaction,
+            recipient: "notValid",
+          });
 
           expect(tx).toEqual({
-            ...transaction,
-            additionalFees: undefined,
-            feesStrategy: "custom",
-            gasPrice: new BigNumber(0),
-            type: 0,
+            ...nftTransaction,
+            nft: {
+              ...nftTransaction.nft,
+              collectionName: "Bored Ape",
+            },
+            recipient: "notValid",
+            maxFeePerGas: new BigNumber(1),
+            maxPriorityFeePerGas: new BigNumber(1),
+            gasPrice: undefined,
+            gasLimit: new BigNumber(0),
+            data: undefined,
+            type: 2,
           });
         });
-      });
 
-      describe("When gasOptions provided", () => {
-        it("should call getFeesEstimation once", async () => {
-          const tx = await prepareTransaction(account, {
-            ...transaction,
-            gasOptions: undefined,
+        it("should have a gasLimit = 0 when amount has an error", async () => {
+          jest.spyOn(rpcAPI, "getGasEstimation").mockImplementation(async () => {
+            throw new Error();
           });
 
-          expect(rpcAPI.getFeesEstimation).toBeCalledTimes(1);
+          const tx = await prepareTransaction(account, {
+            ...nftTransaction,
+            amount: new BigNumber(0),
+          });
 
           expect(tx).toEqual({
-            ...transaction,
+            ...nftTransaction,
+            nft: {
+              ...nftTransaction.nft,
+              collectionName: "Bored Ape",
+            },
+            amount: new BigNumber(0),
             maxFeePerGas: new BigNumber(1),
             maxPriorityFeePerGas: new BigNumber(1),
+            gasPrice: undefined,
+            gasLimit: new BigNumber(0),
+            data: expectedData(account, nftTransaction, "erc721"),
             type: 2,
           });
         });
-      });
 
-      describe("When gasOptions provided", () => {
-        const gasOptions: GasOptions = {
-          slow: {
-            maxFeePerGas: new BigNumber(10),
-            maxPriorityFeePerGas: new BigNumber(1),
-            gasPrice: null,
-          },
-          medium: {
-            maxFeePerGas: new BigNumber(20),
-            maxPriorityFeePerGas: new BigNumber(2),
-            gasPrice: null,
-          },
-          fast: {
-            maxFeePerGas: new BigNumber(30),
-            maxPriorityFeePerGas: new BigNumber(3),
-            gasPrice: null,
-          },
-        };
-        it("should use gasOptions values for fee data", async () => {
-          const tx = await prepareTransaction(account, {
-            ...transaction,
-            gasOptions,
+        describe("ERC721", () => {
+          it("should return an EIP1559 erc721 nft transaction", async () => {
+            const tx = await prepareTransaction(account, {
+              ...nftTransaction,
+            });
+
+            expect(tx).toEqual({
+              ...nftTransaction,
+              data: expectedData(account, tx, "erc721"),
+              nft: {
+                ...nftTransaction.nft,
+                collectionName: "Bored Ape",
+              },
+              gasPrice: undefined,
+              maxFeePerGas: new BigNumber(1),
+              maxPriorityFeePerGas: new BigNumber(1),
+              type: 2,
+            });
           });
 
-          expect(rpcAPI.getFeesEstimation).toBeCalledTimes(0);
+          it("should return a legacy erc721 nft transaction", async () => {
+            jest.spyOn(rpcAPI, "getFeesEstimation").mockImplementationOnce(async () => ({
+              gasPrice: new BigNumber(1),
+              maxFeePerGas: null,
+              maxPriorityFeePerGas: null,
+            }));
+            const tx = await prepareTransaction(account, {
+              ...nftTransaction,
+            });
+
+            expect(tx).toEqual({
+              ...nftTransaction,
+              data: expectedData(account, tx, "erc721"),
+              nft: {
+                ...nftTransaction.nft,
+                collectionName: "Bored Ape",
+              },
+              maxFeePerGas: undefined,
+              maxPriorityFeePerGas: undefined,
+              gasPrice: new BigNumber(1),
+              type: 0,
+            });
+          });
+        });
 
-          expect(tx).toEqual({
-            ...transaction,
-            gasOptions,
-            additionalFees: undefined,
-            maxFeePerGas: new BigNumber(20),
-            maxPriorityFeePerGas: new BigNumber(2),
-            type: 2,
+        describe("ERC1155", () => {
+          it("should return an EIP1559 erc1155 nft transaction", async () => {
+            const tx = await prepareTransaction(account, {
+              ...nftTransaction,
+              mode: "erc1155",
+            });
+
+            expect(tx).toEqual({
+              ...nftTransaction,
+              mode: "erc1155",
+              data: expectedData(account, tx, "erc1155"),
+              nft: {
+                ...nftTransaction.nft,
+                collectionName: "Bored Ape",
+              },
+              gasPrice: undefined,
+              maxFeePerGas: new BigNumber(1),
+              maxPriorityFeePerGas: new BigNumber(1),
+              type: 2,
+            });
+          });
+
+          it("should return a legacy erc1155 nft transaction", async () => {
+            jest.spyOn(rpcAPI, "getFeesEstimation").mockImplementationOnce(async () => ({
+              gasPrice: new BigNumber(1),
+              maxFeePerGas: null,
+              maxPriorityFeePerGas: null,
+            }));
+            const tx = await prepareTransaction(account, {
+              ...nftTransaction,
+              mode: "erc1155",
+            });
+
+            expect(tx).toEqual({
+              ...nftTransaction,
+              mode: "erc1155",
+              data: expectedData(account, tx, "erc1155"),
+              nft: {
+                ...nftTransaction.nft,
+                collectionName: "Bored Ape",
+              },
+              maxFeePerGas: undefined,
+              maxPriorityFeePerGas: undefined,
+              gasPrice: new BigNumber(1),
+              type: 0,
+            });
           });
         });
       });
@@ -444,6 +610,15 @@ describe("EVM Family", () => {
           nonce: 10,
         });
       });
+
+      it("should update an NFT transaction with the correct recipient", async () => {
+        expect(await prepareForSignOperation(account, nftTransaction)).toEqual({
+          ...nftTransaction,
+          amount: new BigNumber(0),
+          recipient: nftTransaction.nft.contract,
+          nonce: 10,
+        });
+      });
     });
   });
 });

package/src/__tests__/{signOperation.unit.test.ts → unit/signOperation.unit.test.ts}

@@ -1,14 +1,14 @@
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
-import { buildSignOperation, applyEIP155 } from "../signOperation";
-import { Transaction as EvmTransaction } from "../types";
-import * as rpcAPI from "../api/rpc/rpc.common";
-import { getEstimatedFees } from "../logic";
-import { makeAccount } from "../testUtils";
-import { EvmAddress, EvmSignature, EvmSigner } from "../signer";
+import { Account } from "@ledgerhq/types-live";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { getCryptoCurrencyById, listCryptoCurrencies } from "@ledgerhq/cryptoassets";
+import { buildSignOperation, applyEIP155 } from "../../signOperation";
+import { EvmAddress, EvmSignature, EvmSigner } from "../../signer";
+import { Transaction as EvmTransaction } from "../../types";
+import { makeAccount } from "../fixtures/common.fixtures";
+import * as rpcAPI from "../../api/rpc/rpc.common";
+import { getEstimatedFees } from "../../logic";
 
 const currency: CryptoCurrency = {
   ...getCryptoCurrencyById("ethereum"),
@@ -44,6 +44,7 @@ const mockSignerContext: SignerContext<EvmSigner, EvmAddress | EvmSignature> = (
   fn: (signer: EvmSigner) => Promise<EvmAddress | EvmSignature>,
 ) => {
   return fn({
+    setLoadConfig: jest.fn(),
     getAddress: jest.fn(),
     signTransaction: () =>
       Promise.resolve({
@@ -51,6 +52,9 @@ const mockSignerContext: SignerContext<EvmSigner, EvmAddress | EvmSignature> = (
         s: "abc",
         v: "27",
       }),
+    signEIP712HashedMessage: jest.fn(),
+    signEIP712Message: jest.fn(),
+    signPersonalMessage: jest.fn(),
   });
 };
 
@@ -119,17 +123,11 @@ describe("EVM Family", () => {
     });
 
     describe("applyEIP155", () => {
-      const chainIds = [
-        1, //ethereum
-        5, // goerli
-        10, // optimism
-        14, // flare
-        19, // songbird
-        56, // bsc
-        137, // polygon
-        250, // fantom
-        1284, // moonbeam
-      ];
+      const chainIds = listCryptoCurrencies(true)
+        .filter(c => c.family === "evm")
+        .map(c => c.ethereumLikeInfo!.chainId)
+        .sort((a, b) => a - b);
+
       const possibleHexV = [
         "00", // 0 - ethereum + testnets should always retrun 0/1 from hw-app-eth
         "01", // 1