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

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

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
 import {
   AmountRequired,
   ETHAddressNonEIP,
@@ -12,9 +10,11 @@ import {
   RecipientRequired,
 } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
-import getTransactionStatus from "../getTransactionStatus";
-import { makeAccount, makeTokenAccount } from "../testUtils";
-import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../types";
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { makeAccount, makeTokenAccount } from "../fixtures/common.fixtures";
+import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../../types";
+import getTransactionStatus from "../../getTransactionStatus";
+import { NotEnoughNftOwned, NotOwnedNft, QuantityNeedsToBePositive } from "../../errors";
 
 const recipient = "0xe2ca7390e76c5A992749bB622087310d2e63ca29"; // rambo.eth
 const testData = Buffer.from("testBufferString").toString("hex");
@@ -331,6 +331,122 @@ describe("EVM Family", () => {
       });
     });
 
+    describe("Nft", () => {
+      describe("ERC721", () => {
+        const nft = {
+          contract: "0xNftContract",
+          tokenId: "1",
+          amount: new BigNumber(1),
+          currencyId: account.currency.id,
+          id: "doesn't matter",
+          standard: "ERC721" as const,
+        };
+
+        it("should detect a transaction for an ERC721 nft not owned by the account and have an error", async () => {
+          const tx = {
+            ...eip1559Tx,
+            mode: "erc721" as const,
+            nft: {
+              collectionName: "",
+              contract: nft.contract,
+              tokenId: nft.tokenId,
+              quantity: new BigNumber(1),
+            },
+          };
+          const res = await getTransactionStatus(account, tx);
+
+          expect(res.errors).toEqual(
+            expect.objectContaining({
+              amount: new NotOwnedNft(),
+            }),
+          );
+        });
+      });
+
+      describe("ERC1155", () => {
+        const nft = {
+          contract: "0xAnotherNftContract",
+          tokenId: "2",
+          amount: new BigNumber(2),
+          currencyId: account.currency.id,
+          id: "still doesn't matter",
+          standard: "ERC1155" as const,
+        };
+
+        it("should detect a transaction for an ERC1155 nft not owned by the account and have an error", async () => {
+          const tx = {
+            ...eip1559Tx,
+            mode: "erc1155" as const,
+            nft: {
+              collectionName: "",
+              contract: nft.contract,
+              tokenId: nft.tokenId,
+              quantity: new BigNumber(1),
+            },
+          };
+          const res = await getTransactionStatus(account, tx);
+
+          expect(res.errors).toEqual(
+            expect.objectContaining({
+              amount: new NotOwnedNft(),
+            }),
+          );
+        });
+
+        it("should detect a transaction for an ERC1155 where the quantity is 0 or below and have an error", async () => {
+          const tx = {
+            ...eip1559Tx,
+            mode: "erc1155" as const,
+            nft: {
+              collectionName: "",
+              contract: nft.contract,
+              tokenId: nft.tokenId,
+              quantity: new BigNumber(0),
+            },
+          };
+          const res = await getTransactionStatus(
+            {
+              ...account,
+              nfts: [nft],
+            },
+            tx,
+          );
+
+          expect(res.errors).toEqual(
+            expect.objectContaining({
+              amount: new QuantityNeedsToBePositive(),
+            }),
+          );
+        });
+
+        it("should detect a transaction for an ERC1155 nft but the account doesn't own enough of it and have an error", async () => {
+          const tx = {
+            ...eip1559Tx,
+            mode: "erc1155" as const,
+            nft: {
+              collectionName: "",
+              contract: nft.contract,
+              tokenId: nft.tokenId,
+              quantity: new BigNumber(3),
+            },
+          };
+          const res = await getTransactionStatus(
+            {
+              ...account,
+              nfts: [nft],
+            },
+            tx,
+          );
+
+          expect(res.errors).toEqual(
+            expect.objectContaining({
+              amount: new NotEnoughNftOwned(),
+            }),
+          );
+        });
+      });
+    });
+
     describe("Global return", () => {
       it("should return the expected informations", async () => {
         const res = await getTransactionStatus(account, legacyTx);

package/src/__tests__/{hw-getAddress.unit.test.ts → unit/hw-getAddress.unit.test.ts}

@@ -1,6 +1,6 @@
 import eip55 from "eip55";
-import resolver from "../hw-getAddress";
-import { EvmAddress, EvmSignature, EvmSigner } from "../signer";
+import { EvmAddress, EvmSignature, EvmSigner } from "../../signer";
+import resolver from "../../hw-getAddress";
 
 const address = "0xc3f95102D5c8F2c83e49Ce3Acfb905eDfb7f37dE";
 jest.mock(
@@ -18,11 +18,15 @@ const mockSignerFactory = (
   fn: (signer: EvmSigner) => Promise<EvmAddress | EvmSignature>,
 ) =>
   fn({
+    setLoadConfig: jest.fn(),
     getAddress: async () => ({
       publicKey: "",
       address: address.toLowerCase(),
     }),
     signTransaction: jest.fn(),
+    signEIP712HashedMessage: jest.fn(),
+    signEIP712Message: jest.fn(),
+    signPersonalMessage: jest.fn(),
   });
 
 describe("EVM Family", () => {

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

@@ -0,0 +1,192 @@
+import { fail, AssertionError } from "assert";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { prepareMessageToSign, signMessage } from "../../hw-signMessage";
+import { makeAccount } from "../fixtures/common.fixtures";
+
+const signPersonalMessage = jest.fn(async () => ({
+  r: "01",
+  s: "02",
+  v: 3,
+}));
+const signEIP712Message = jest.fn(async () => ({
+  r: "03",
+  s: "04",
+  v: 6,
+}));
+const signEIP712HashedMessage = jest.fn(async () => ({
+  r: "07",
+  s: "08",
+  v: 9,
+}));
+
+const signerContextMock: any = async (deviceId: string, fn: any) => {
+  return fn({
+    signPersonalMessage,
+    signEIP712Message,
+    signEIP712HashedMessage,
+  });
+};
+
+const account = makeAccount(
+  "0x6cBCD73CD8e8a42844662f0A0e76D7F79Afd933d",
+  getCryptoCurrencyById("ethereum"),
+);
+
+const eip712message = {
+  domain: {
+    name: "Message Not In CAL",
+    version: "1",
+    chainId: 1,
+    verifyingContract: "0xd007d007a0d06d4fbbf627410eade051fd66fc59",
+    salt: "0x446f6f7420446f6f74206c657320746f6361726473206475205661756c740000",
+  },
+  types: {
+    EIP712Domain: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" },
+    ],
+    hello: [{ name: "foo", type: "string" }],
+  },
+  primaryType: "hello",
+  message: {
+    foo: "bar",
+  },
+};
+
+describe("EVM Family", () => {
+  describe("hw-signMessage.ts", () => {
+    describe("prepareMessageToSign", () => {
+      it("should parse a random stringified JSON message and still return an EIP191 message", () => {
+        expect(
+          prepareMessageToSign({ message: JSON.stringify({ randomMessage: "hello" }) }),
+        ).toEqual({
+          standard: "EIP191",
+          message: JSON.stringify({ randomMessage: "hello" }),
+        });
+      });
+
+      it("should parse a stringified JSON message and still return an EIP712 message", () => {
+        expect(prepareMessageToSign({ message: JSON.stringify(eip712message) })).toEqual({
+          standard: "EIP712",
+          message: eip712message,
+          domainHash: "0x471d9cd0511bdacb81977703f269a417092da548042b004ee44f250c077aefd6",
+          hashStruct: "0x00ea67203532137e1166447586859962e977f0ce26dc2b53c2f5c9415665a52d",
+        });
+      });
+
+      it("should return an EIP91 message with a basic string message", () => {
+        expect(prepareMessageToSign({ message: "test message" })).toEqual({
+          standard: "EIP191",
+          message: "test message",
+        });
+      });
+    });
+
+    describe("signMessage", () => {
+      beforeEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should sign an EIP191 message", async () => {
+        const result = await signMessage(signerContextMock)("", account, {
+          standard: "EIP191",
+          message: "test message",
+        });
+        expect(result).toEqual({
+          rsv: {
+            r: "01",
+            s: "02",
+            v: 3,
+          },
+          signature:
+            "0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000021b",
+        });
+        expect(signPersonalMessage).toHaveBeenCalled();
+      });
+
+      it("should sign an EIP712 message with signEIP712Message", async () => {
+        const result = await signMessage(signerContextMock)("", account, {
+          standard: "EIP712",
+          message: eip712message,
+          domainHash: "0x471d9cd0511bdacb81977703f269a417092da548042b004ee44f250c077aefd6",
+          hashStruct: "0x00ea67203532137e1166447586859962e977f0ce26dc2b53c2f5c9415665a52d",
+        });
+        expect(result).toEqual({
+          rsv: {
+            r: "03",
+            s: "04",
+            v: 6,
+          },
+          signature:
+            "0x000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000041c",
+        });
+        expect(signEIP712Message).toHaveBeenCalled();
+      });
+
+      it("should sign an EIP712 message and fallback on signEIP712Message when signEIP712Message is not supported", async () => {
+        signEIP712Message.mockImplementationOnce(() => {
+          const e = new Error();
+          (e as any).statusText = "INS_NOT_SUPPORTED";
+
+          throw e;
+        });
+
+        const result = await signMessage(signerContextMock)("", account, {
+          standard: "EIP712",
+          message: eip712message,
+          domainHash: "0x471d9cd0511bdacb81977703f269a417092da548042b004ee44f250c077aefd6",
+          hashStruct: "0x00ea67203532137e1166447586859962e977f0ce26dc2b53c2f5c9415665a52d",
+        });
+        expect(result).toEqual({
+          rsv: {
+            r: "07",
+            s: "08",
+            v: 9,
+          },
+          signature:
+            "0x000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000081b",
+        });
+        expect(signEIP712HashedMessage).toHaveBeenCalled();
+      });
+
+      it("should throw for any other error", async () => {
+        signEIP712Message.mockImplementationOnce(() => {
+          throw new Error();
+        });
+
+        try {
+          await signMessage(signerContextMock)("", account, {
+            standard: "EIP712",
+            message: eip712message,
+            domainHash: "0x471d9cd0511bdacb81977703f269a417092da548042b004ee44f250c077aefd6",
+            hashStruct: "0x00ea67203532137e1166447586859962e977f0ce26dc2b53c2f5c9415665a52d",
+          });
+          fail("Promise should have been rejected");
+        } catch (e) {
+          if (e instanceof AssertionError) {
+            throw e;
+          }
+          expect(e).toBeInstanceOf(Error);
+        }
+      });
+
+      it("should throw for an unsupported message standard", async () => {
+        try {
+          await signMessage(signerContextMock)("", account, {
+            message: "test",
+          });
+          fail("Promise should have been rejected");
+        } catch (e) {
+          if (e instanceof AssertionError) {
+            throw e;
+          }
+          expect(e).toBeInstanceOf(Error);
+          expect((e as Error).message).toEqual("Unsupported message standard");
+        }
+      });
+    });
+  });
+});

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

@@ -1,18 +1,26 @@
-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/rpc.common";
+import { getEnv, setEnv } from "@ledgerhq/live-env";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import * as cryptoAssetsTokens from "@ledgerhq/cryptoassets/tokens";
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../../types";
+import * as RPC_API from "../../api/rpc/rpc.common";
+import {
+  deepFreeze,
+  makeAccount,
+  makeNftOperation,
+  makeOperation,
+  makeTokenAccount,
+} from "../fixtures/common.fixtures";
 import {
+  attachOperations,
   eip1559TransactionHasFees,
   getAdditionalLayer2Fees,
   getEstimatedFees,
   getSyncHash,
   legacyTransactionHasFees,
   mergeSubAccounts,
-} from "../logic";
-import { makeAccount, makeOperation, makeTokenAccount } from "../testUtils";
-import { EvmTransactionEIP1559, EvmTransactionLegacy } from "../types";
+} from "../../logic";
 
 describe("EVM Family", () => {
   describe("logic.ts", () => {
@@ -258,7 +266,9 @@ describe("EVM Family", () => {
           ...makeTokenAccount("0xkvn", getTokenById("ethereum/erc20/usd__coin")),
           balance: new BigNumber(1),
         };
-        const account = makeAccount("0xkvn", getCryptoCurrencyById("ethereum"));
+        const account = {
+          ...makeAccount("0xkvn", getCryptoCurrencyById("ethereum")),
+        };
         delete account.subAccounts;
 
         const newSubAccounts = mergeSubAccounts(account, [tokenAccount]);
@@ -285,8 +295,14 @@ describe("EVM Family", () => {
     describe("getSyncHash", () => {
       const currency = getCryptoCurrencyById("ethereum");
 
+      let oldEnv: string;
+      beforeAll(() => {
+        oldEnv = getEnv("NFT_CURRENCIES");
+      });
+
       afterEach(() => {
         jest.restoreAllMocks();
+        setEnv("NFT_CURRENCIES", oldEnv);
       });
 
       it("should provide a valid sha256 hash", () => {
@@ -354,6 +370,125 @@ describe("EVM Family", () => {
           });
         expect(getSyncHash(currency)).not.toEqual(getSyncHash(currency));
       });
+
+      it("should provide a new hash if nft support is activated or not", () => {
+        setEnv("NFT_CURRENCIES", "");
+        const hash1 = getSyncHash(currency);
+        setEnv("NFT_CURRENCIES", currency.id);
+        const hash2 = getSyncHash(currency);
+
+        expect(hash1).not.toEqual(hash2);
+      });
+    });
+
+    describe("attachOperations", () => {
+      it("should attach token & nft operations to coin operations and create 'NONE' coin operations in case of orphans child operations", () => {
+        const coinOperation = makeOperation({
+          hash: "0xCoinOp3Hash",
+        });
+        const tokenOperations = [
+          makeOperation({
+            hash: coinOperation.hash,
+            contract: "0xTokenContract",
+            value: new BigNumber(1),
+            type: "OUT",
+          }),
+          makeOperation({
+            hash: coinOperation.hash,
+            contract: "0xTokenContract",
+            value: new BigNumber(2),
+            type: "IN",
+          }),
+          makeOperation({
+            hash: "0xUnknownHash",
+            contract: "0xOtherTokenContract",
+            value: new BigNumber(2),
+            type: "IN",
+          }),
+        ];
+        const nftOperations = [
+          makeNftOperation({
+            hash: coinOperation.hash,
+            contract: "0xTokenContract",
+            value: new BigNumber(1),
+            type: "NFT_OUT",
+          }),
+          makeNftOperation({
+            hash: coinOperation.hash,
+            contract: "0xTokenContract",
+            value: new BigNumber(2),
+            type: "NFT_IN",
+          }),
+          makeNftOperation({
+            hash: "0xUnknownNftHash",
+            contract: "0xOtherNftTokenContract",
+            value: new BigNumber(2),
+            type: "NFT_IN",
+          }),
+        ];
+
+        expect(attachOperations([coinOperation], tokenOperations, nftOperations)).toEqual([
+          {
+            ...coinOperation,
+            subOperations: [tokenOperations[0], tokenOperations[1]],
+            nftOperations: [nftOperations[0], nftOperations[1]],
+          },
+          {
+            ...tokenOperations[2],
+            id: `js:2:ethereum:0xkvn:-${tokenOperations[2].hash}-NONE`,
+            type: "NONE",
+            value: new BigNumber(0),
+            fee: new BigNumber(0),
+            senders: [],
+            recipients: [],
+            nftOperations: [],
+            subOperations: [tokenOperations[2]],
+            accountId: "",
+            contract: undefined,
+          },
+          {
+            ...nftOperations[2],
+            id: `js:2:ethereum:0xkvn:-${nftOperations[2].hash}-NONE`,
+            type: "NONE",
+            value: new BigNumber(0),
+            fee: new BigNumber(0),
+            senders: [],
+            recipients: [],
+            nftOperations: [nftOperations[2]],
+            subOperations: [],
+            accountId: "",
+            contract: undefined,
+          },
+        ]);
+      });
+
+      it("should not mutate the original operations", () => {
+        const coinOperations = deepFreeze([
+          makeOperation({
+            hash: "0xCoinOp3Hash",
+          }),
+        ]);
+        const tokenOperations = deepFreeze([
+          makeOperation({
+            hash: coinOperations[0].hash,
+            contract: "0xTokenContract",
+            value: new BigNumber(1),
+            type: "OUT",
+          }),
+        ]);
+        const nftOperations = deepFreeze([
+          makeNftOperation({
+            hash: coinOperations[0].hash,
+            contract: "0xTokenContract",
+            value: new BigNumber(1),
+            type: "NFT_OUT",
+          }),
+        ]);
+        expect(
+          // @ts-expect-error purposely ignore readonly ts issue for this
+          () => attachOperations(coinOperations, tokenOperations, nftOperations),
+        ).not.toThrow(); // mutation prevented by deepFreeze method
+      });
     });
   });
 });