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

package/src/__tests__/unit/api/explorer/etherscan.unit.test.ts

@@ -0,0 +1,563 @@
+import axios from "axios";
+import { AssertionError, fail } from "assert";
+import { delay } from "@ledgerhq/live-promise";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import * as ETHERSCAN_API from "../../../../api/explorer/etherscan";
+import { makeAccount } from "../../../fixtures/common.fixtures";
+import {
+  etherscanCoinOperations,
+  etherscanERC1155Operations,
+  etherscanERC721Operations,
+  etherscanTokenOperations,
+} from "../../../fixtures/etherscan.fixtures";
+import {
+  etherscanERC1155EventToOperations,
+  etherscanERC20EventToOperations,
+  etherscanERC721EventToOperations,
+  etherscanOperationToOperations,
+} from "../../../../adapters";
+
+jest.mock("axios");
+jest.mock("@ledgerhq/live-promise");
+(delay as jest.Mock).mockImplementation(
+  () => new Promise(resolve => setTimeout(resolve, 1)), // mocking the delay supposed to happen after each try
+);
+
+const currency: CryptoCurrency = {
+  ...getCryptoCurrencyById("ethereum"),
+  ethereumLikeInfo: {
+    chainId: 1,
+    explorer: {
+      type: "etherscan",
+      uri: "mock",
+    },
+  },
+};
+const account = makeAccount("0x6cBCD73CD8e8a42844662f0A0e76D7F79Afd933d", currency);
+
+describe("EVM Family", () => {
+  describe("api/explorer/etherscan.ts", () => {
+    afterAll(() => {
+      jest.restoreAllMocks();
+    });
+
+    describe("fetchWithRetries", () => {
+      afterEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should retry on fail", async () => {
+        let retries = 2;
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => {
+          if (retries) {
+            --retries;
+            throw new Error();
+          }
+          return { data: { result: true } };
+        });
+        const response = await ETHERSCAN_API.fetchWithRetries({}, retries);
+
+        expect(response).toBe(true);
+        // it should fail 2 times and succeed on the next try
+        expect(spy).toBeCalledTimes(3);
+      });
+
+      it("should throw after too many retries", async () => {
+        const SpyError = class SpyError extends Error {};
+
+        let retries = ETHERSCAN_API.DEFAULT_RETRIES_API + 1;
+        jest.spyOn(axios, "request").mockImplementation(async () => {
+          if (retries) {
+            --retries;
+            throw new SpyError();
+          }
+          return { data: { result: true } };
+        });
+        try {
+          await ETHERSCAN_API.fetchWithRetries({});
+          fail("Promise should have been rejected");
+        } catch (e) {
+          if (e instanceof AssertionError) {
+            throw e;
+          }
+          expect(e).toBeInstanceOf(SpyError);
+        }
+      });
+
+      it("should also retry if the Etherscan reponse is a 200 w/ a NOTOK message (used for rate limit)", async () => {
+        let retries = 2;
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => {
+          if (retries) {
+            --retries;
+            return { data: { message: "NOTOK" } };
+          }
+          return { data: { result: true } };
+        });
+        const response = await ETHERSCAN_API.fetchWithRetries({}, retries);
+
+        expect(response).toBe(true);
+        // it should fail 2 times and succeed on the next try
+        expect(spy).toBeCalledTimes(3);
+      });
+    });
+
+    describe("getLastCoinOperations", () => {
+      afterEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should return an empty array if the currency is misconfigured", async () => {
+        jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanCoinOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastCoinOperations(
+          {
+            ...currency,
+            ethereumLikeInfo: {
+              chainId: 1,
+              // no explorer
+            },
+          },
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual([]);
+      });
+
+      it("should return a flat list of coin transactions from block 0", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanCoinOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastCoinOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual(
+          etherscanCoinOperations.map(op => etherscanOperationToOperations(account.id, op)).flat(),
+        );
+        expect(response.length).toBe(4);
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=txlist&address=${account.freshAddress}&tag=latest&page=1&sort=desc`,
+        });
+      });
+
+      it("should return a flat list of coin transactions from block 50", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanCoinOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastCoinOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+        );
+
+        expect(response).toEqual(
+          etherscanCoinOperations.map(op => etherscanOperationToOperations(account.id, op)).flat(),
+        );
+        expect(response.length).toBe(4);
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=txlist&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50`,
+        });
+      });
+
+      it("should return a flat list of coin transactions from block 50 to block 100", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanCoinOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastCoinOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+          100,
+        );
+
+        expect(response).toEqual(
+          etherscanCoinOperations.map(op => etherscanOperationToOperations(account.id, op)).flat(),
+        );
+        expect(response.length).toBe(4);
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=txlist&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50&endBlock=100`,
+        });
+      });
+    });
+
+    describe("getLastTokenOperations", () => {
+      afterEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should return an empty array if the currency is misconfigured", async () => {
+        jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanTokenOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastTokenOperations(
+          {
+            ...currency,
+            ethereumLikeInfo: {
+              chainId: 1,
+              // no explorer
+            },
+          },
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual([]);
+      });
+
+      it("should return a flat list of token transactions from block 0", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanTokenOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastTokenOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[0], 0),
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[1], 0),
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=tokentx&address=${account.freshAddress}&tag=latest&page=1&sort=desc`,
+        });
+      });
+
+      it("should return a flat list of token transactions from block 50", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanTokenOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastTokenOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[0], 0),
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[1], 0),
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=tokentx&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50`,
+        });
+      });
+
+      it("should return a flat list of token transactions from block 50 to block 100", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanTokenOperations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastTokenOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+          100,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[0], 0),
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[1], 0),
+            etherscanERC20EventToOperations(account.id, etherscanTokenOperations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=tokentx&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50&endBlock=100`,
+        });
+      });
+    });
+
+    describe("getLastERC721Operations", () => {
+      afterEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should return an empty array if the currency is misconfigured", async () => {
+        jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC721Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC721Operations(
+          {
+            ...currency,
+            ethereumLikeInfo: {
+              chainId: 1,
+              // no explorer
+            },
+          },
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual([]);
+      });
+
+      it("should return a flat list of erc721 transactions from block 0", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC721Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC721Operations(
+          currency,
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[0], 0),
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[1], 0),
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=tokennfttx&address=${account.freshAddress}&tag=latest&page=1&sort=desc`,
+        });
+      });
+
+      it("should return a flat list of erc721 transactions from block 50", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC721Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC721Operations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[0], 0),
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[1], 0),
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=tokennfttx&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50`,
+        });
+      });
+
+      it("should return a flat list of erc721 transactions from block 50 to block 100", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC721Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC721Operations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+          100,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[0], 0),
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[1], 0),
+            etherscanERC721EventToOperations(account.id, etherscanERC721Operations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=tokennfttx&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50&endBlock=100`,
+        });
+      });
+    });
+
+    describe("getLastERC1155Operations", () => {
+      afterEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it("should return an empty array if the currency is misconfigured", async () => {
+        jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC721Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC1155Operations(
+          {
+            ...currency,
+            ethereumLikeInfo: {
+              chainId: 1,
+              // no explorer
+            },
+          },
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual([]);
+      });
+
+      it("should return a flat list of erc1155 transactions from block 0", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC1155Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC1155Operations(
+          currency,
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[0], 0),
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[1], 0),
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=token1155tx&address=${account.freshAddress}&tag=latest&page=1&sort=desc`,
+        });
+      });
+
+      it("should return a flat list of erc1155 transactions from block 50", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC1155Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC1155Operations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[0], 0),
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[1], 0),
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=token1155tx&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50`,
+        });
+      });
+
+      it("should return a flat list of erc1155 transactions from block 50 to block 100", async () => {
+        const spy = jest.spyOn(axios, "request").mockImplementation(async () => ({
+          data: {
+            result: etherscanERC1155Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastERC1155Operations(
+          currency,
+          account.freshAddress,
+          account.id,
+          50,
+          100,
+        );
+
+        expect(response).toEqual(
+          [
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[0], 0),
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[1], 0),
+            etherscanERC1155EventToOperations(account.id, etherscanERC1155Operations[2], 1),
+          ].flat(),
+        );
+        expect(spy).toBeCalledWith({
+          method: "GET",
+          url: `mock/api?module=account&action=token1155tx&address=${account.freshAddress}&tag=latest&page=1&sort=desc&startBlock=50&endBlock=100`,
+        });
+      });
+    });
+
+    describe("getLastNftOperations", () => {
+      it("should return a sorted array of nft transactions", async () => {
+        jest.spyOn(axios, "request").mockImplementation(async params => ({
+          data: {
+            result: params.url?.includes("tokennfttx")
+              ? etherscanERC721Operations
+              : etherscanERC1155Operations,
+          },
+        }));
+
+        const response = await ETHERSCAN_API.getLastNftOperations(
+          currency,
+          account.freshAddress,
+          account.id,
+          0,
+        );
+
+        expect(response).toEqual(
+          response.slice().sort((a, b) => b.date.getTime() - a.date.getTime()),
+        );
+      });
+    });
+  });
+});

package/src/__tests__/unit/api/explorer/index.unit.test.ts

@@ -0,0 +1,36 @@
+import { AssertionError, fail } from "assert";
+import { getExplorerApi } from "../../../../api/explorer";
+import etherscanLikeApi from "../../../../api/explorer/etherscan";
+
+describe("EVM Family", () => {
+  describe("api/explorer/index.ts", () => {
+    describe("getExplorerApi", () => {
+      it("should throw when requesting a non existing explorer", async () => {
+        try {
+          await getExplorerApi({
+            id: "not-existing",
+            ethereumLikeInfo: { explorer: { type: "anything", uri: "notworking" } },
+          } as any);
+          fail("Promise should have been rejected");
+        } catch (e) {
+          if (e instanceof AssertionError) {
+            throw e;
+          }
+          expect((e as Error).message).toEqual(`No explorer found for currency "not-existing"`);
+        }
+      });
+
+      it("should return the etherscan api", async () => {
+        const explorerA = await getExplorerApi({
+          ethereumLikeInfo: { explorer: { type: "etherscan", uri: "working" } },
+        } as any);
+        const explorerB = await getExplorerApi({
+          ethereumLikeInfo: { explorer: { type: "blockscout", uri: "working" } },
+        } as any);
+
+        expect(explorerA).toBe(etherscanLikeApi);
+        expect(explorerB).toBe(etherscanLikeApi);
+      });
+    });
+  });
+});

package/src/__tests__/{gasTracker → unit/api/gasTracker}/index.unit.test.ts

@@ -1,6 +1,6 @@
 import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
-import { getGasTracker } from "../../api/gasTracker";
-import { getGasOptions as ledgerGetGasOptions } from "../../api/gasTracker/ledger";
+import { getGasTracker } from "../../../../api/gasTracker";
+import { getGasOptions as ledgerGetGasOptions } from "../../../../api/gasTracker/ledger";
 
 const fakeCurrency: Partial<CryptoCurrency> = {
   id: "my_new_chain" as CryptoCurrencyId,
@@ -22,7 +22,7 @@ const fakeCurrencyWithoutGasTracker: Partial<CryptoCurrency> = {
 };
 
 describe("EVM Family", () => {
-  describe("gasTracker", () => {
+  describe("api/gasTracker/index.ts", () => {
     it("should return null if no gas tracker is found", () => {
       expect(getGasTracker(fakeCurrencyWithoutGasTracker as CryptoCurrency)).toBeNull();
     });

package/src/__tests__/{gasTracker → unit/api/gasTracker}/ledger.unit.test.ts

@@ -1,9 +1,9 @@
 import network from "@ledgerhq/live-network/network";
 import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
 import BigNumber from "bignumber.js";
-import { GasOptions } from "../../types";
+import { GasOptions } from "../../../../types";
 import { getEnv, setEnv } from "@ledgerhq/live-env";
-import { getGasOptions } from "../../api/gasTracker/ledger";
+import { getGasOptions } from "../../../../api/gasTracker/ledger";
 jest.mock("@ledgerhq/live-network/network");
 
 const fakeCurrency: Partial<CryptoCurrency> = {
@@ -19,7 +19,7 @@ const fakeCurrency: Partial<CryptoCurrency> = {
 };
 
 describe("EVM Family", () => {
-  describe("gasTracker", () => {
+  describe("api/gasTracker/index.ts", () => {
     const originalEIP1559_BASE_FEE_MULTIPLIER: number = getEnv("EIP1559_BASE_FEE_MULTIPLIER");
 
     beforeAll(() => {

package/src/__tests__/{rpc.unit.test.ts → unit/api/rpc/rpc.unit.test.ts}

@@ -1,12 +1,12 @@
+import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { AssertionError, fail } from "assert";
 import { delay } from "@ledgerhq/live-promise";
 import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
-import { AssertionError, fail } from "assert";
-import BigNumber from "bignumber.js";
-import { ethers } from "ethers";
-import * as RPC_API from "../api/rpc/rpc.common";
-import { GasEstimationError, InsufficientFunds } from "../errors";
-import { makeAccount } from "../testUtils";
-import { Transaction as EvmTransaction, EvmTransactionLegacy } from "../types";
+import { EvmTransactionLegacy, Transaction as EvmTransaction } from "../../../../types";
+import { GasEstimationError, InsufficientFunds } from "../../../../errors";
+import { makeAccount } from "../../../fixtures/common.fixtures";
+import * as RPC_API from "../../../../api/rpc/rpc.common";
 
 const fakeCurrency: Partial<CryptoCurrency> = {
   id: "my_new_chain" as CryptoCurrencyId,
@@ -114,11 +114,14 @@ describe("EVM Family", () => {
       });
   });
 
-  describe("api/rpc.common.ts", () => {
+  describe("api/rpc/rpc.common.ts", () => {
     describe("withApi", () => {
       it("should throw if the currency doesn't have an RPC node", async () => {
         try {
-          await RPC_API.withApi(fakeCurrencyWithoutRPC as CryptoCurrency, (() => {}) as any);
+          await RPC_API.withApi(
+            fakeCurrencyWithoutRPC as CryptoCurrency,
+            (() => Promise.resolve()) as any,
+          );
           fail("Promise should have been rejected");
         } catch (e) {
           if (e instanceof AssertionError) {
@@ -128,8 +131,8 @@ describe("EVM Family", () => {
         }
       });
 
-      it("should retry on fail as many times as the DEFAULT_RETRIES_RPC_METHODS constant is set to", async () => {
-        let retries = RPC_API.DEFAULT_RETRIES_RPC_METHODS;
+      it("should retry on fail", async () => {
+        let retries = 2;
         const spy = jest.fn(async () => {
           if (retries) {
             --retries;
@@ -137,11 +140,11 @@ describe("EVM Family", () => {
           }
           return true;
         });
-        const response = await RPC_API.withApi(fakeCurrency as CryptoCurrency, spy);
+        const response = await RPC_API.withApi(fakeCurrency as CryptoCurrency, spy, retries);
 
         expect(response).toBe(true);
-        // it should fail DEFAULT_RETRIES_RPC_METHODS times and succeed on the next try, therefore the +1
-        expect(spy).toBeCalledTimes(RPC_API.DEFAULT_RETRIES_RPC_METHODS + 1);
+        // it should fail 2 times and succeed on the next try
+        expect(spy).toBeCalledTimes(3);
       });
 
       it("should throw after too many retries", async () => {