@ledgerhq/coin-evm 0.2.0-next.0

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

@@ -0,0 +1,181 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import * as API from "../api/rpc.common";
+import broadcast from "../broadcast";
+import buildOptimisticOperation from "../buildOptimisticOperation";
+import { getEstimatedFees } from "../logic";
+import { makeAccount, makeTokenAccount } from "../testUtils";
+import { Transaction as EvmTransaction } from "../types";
+
+const currency: CryptoCurrency = getCryptoCurrencyById("ethereum");
+const tokenCurrency = getTokenById("ethereum/erc20/usd__coin");
+const tokenAccount: TokenAccount = makeTokenAccount(
+  "0x055C1e159E345cB4197e3844a86A61E0a801d856", // jacquie.eth
+  tokenCurrency
+);
+const account: Account = makeAccount(
+  "0x055C1e159E345cB4197e3844a86A61E0a801d856", // jacquie.eth
+  currency,
+  [tokenAccount]
+);
+const mockedBroadcastResponse = {
+  hash: "0xH4sH",
+  blockNumber: 420,
+  blockHash: "0xBl0cKH4sH",
+  timestamp: Date.now() / 1000, // block timestamps are in seconds
+};
+
+describe("EVM Family", () => {
+  describe("broadcast.ts", () => {
+    beforeAll(() => {
+      jest
+        .spyOn(API, "broadcastTransaction")
+        .mockImplementation(async () => mockedBroadcastResponse as any);
+    });
+
+    afterAll(() => {
+      jest.restoreAllMocks();
+    });
+
+    describe("broadcast", () => {
+      it("should broadcast the coin transaction and fill the blank in the optimistic transaction", async () => {
+        const coinTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: "id",
+          recipient: "0x51DF0aF74a0DBae16cB845B46dAF2a35cB1D4168", // michel.eth
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+        const estimatedFees = getEstimatedFees(coinTransaction);
+        const optimisticCoinOperation = buildOptimisticOperation(
+          account,
+          coinTransaction
+        );
+
+        const finalOperation = await broadcast({
+          account,
+          signedOperation: {
+            operation: optimisticCoinOperation,
+            signature: "0xS1gn4tUR3",
+            expirationDate: null,
+          },
+        });
+
+        expect(API.broadcastTransaction).toBeCalled();
+        expect(finalOperation).toEqual({
+          id: encodeOperationId(
+            account.id,
+            mockedBroadcastResponse.hash,
+            "OUT"
+          ),
+          hash: mockedBroadcastResponse.hash,
+          blockNumber: mockedBroadcastResponse.blockNumber,
+          blockHeight: mockedBroadcastResponse.blockNumber,
+          blockHash: mockedBroadcastResponse.blockHash,
+          value: coinTransaction.amount.plus(estimatedFees),
+          fee: estimatedFees,
+          type: "OUT",
+          senders: [account.freshAddress],
+          recipients: [coinTransaction.recipient],
+          accountId: account.id,
+          transactionSequenceNumber: 0,
+          subOperations: [],
+          date: new Date(mockedBroadcastResponse.timestamp * 1000),
+          extra: {},
+        });
+      });
+
+      it("should broadcast the token transaction and fill the blank in the optimistic transaction", async () => {
+        const tokenTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: tokenAccount.id,
+          recipient: "0x51DF0aF74a0DBae16cB845B46dAF2a35cB1D4168", // michel.eth
+          data: Buffer.from(
+            "a9059cbb00000000000000000000000059569e96d0e3d9728dc07bf5c1443809e6f237fd0000000000000000000000000000000000000000000000000c06701668d322ac",
+            "hex"
+          ),
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(60000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+        const estimatedFees = getEstimatedFees(tokenTransaction);
+        const optimisticTokenOperation = buildOptimisticOperation(
+          account,
+          tokenTransaction
+        );
+
+        const finalOperation = await broadcast({
+          account,
+          signedOperation: {
+            operation: optimisticTokenOperation,
+            signature: "0xS1gn4tUR3",
+            expirationDate: null,
+          },
+        });
+
+        expect(API.broadcastTransaction).toBeCalled();
+        expect(finalOperation).toEqual({
+          id: encodeOperationId(
+            account.id,
+            mockedBroadcastResponse.hash,
+            "FEES"
+          ),
+          hash: mockedBroadcastResponse.hash,
+          blockNumber: mockedBroadcastResponse.blockNumber,
+          blockHeight: mockedBroadcastResponse.blockNumber,
+          blockHash: mockedBroadcastResponse.blockHash,
+          value: estimatedFees,
+          fee: estimatedFees,
+          type: "FEES",
+          senders: [account.freshAddress],
+          recipients: [tokenCurrency?.contractAddress || ""],
+          accountId: account.id,
+          transactionSequenceNumber: 0,
+          date: new Date(mockedBroadcastResponse.timestamp * 1000),
+          subOperations: [
+            {
+              id: encodeOperationId(
+                tokenAccount.id,
+                mockedBroadcastResponse.hash,
+                "OUT"
+              ),
+              hash: mockedBroadcastResponse.hash,
+              blockNumber: mockedBroadcastResponse.blockNumber,
+              blockHeight: mockedBroadcastResponse.blockNumber,
+              blockHash: mockedBroadcastResponse.blockHash,
+              value: new BigNumber(100),
+              fee: estimatedFees,
+              type: "OUT",
+              senders: [account.freshAddress],
+              recipients: [tokenTransaction.recipient],
+              accountId: tokenAccount.id,
+              transactionSequenceNumber: 0,
+              date: new Date(mockedBroadcastResponse.timestamp * 1000),
+              contract: tokenAccount.token.contractAddress,
+              extra: {},
+            },
+          ],
+          extra: {},
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,182 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import BigNumber from "bignumber.js";
+import buildOptimisticOperation from "../buildOptimisticOperation";
+import { getEstimatedFees } from "../logic";
+import { makeAccount, makeTokenAccount } from "../testUtils";
+import { Transaction as EvmTransaction } from "../types";
+
+const currency = getCryptoCurrencyById("ethereum");
+const tokenCurrency = getTokenById("ethereum/erc20/usd__coin");
+const tokenAccount = {
+  ...makeTokenAccount(
+    "0x055C1e159E345cB4197e3844a86A61E0a801d856", // jacquie.eth
+    tokenCurrency
+  ),
+  balance: new BigNumber(150),
+  spendableBalance: new BigNumber(150),
+};
+const account = makeAccount(
+  "0x055C1e159E345cB4197e3844a86A61E0a801d856", // jacquie.eth
+  currency,
+  [tokenAccount]
+);
+
+describe("EVM Family", () => {
+  describe("buildOptimisticOperation.ts", () => {
+    describe("buildOptimisticOperation", () => {
+      it("should create a coin optimistic transaction waiting for the broadcast to be completed", () => {
+        const coinTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: "id",
+          recipient: "0xe2ca7390e76c5A992749bB622087310d2e63ca29", // cortex.eth
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+        const optimistic = buildOptimisticOperation(account, coinTransaction);
+        const estimatedFees = getEstimatedFees(coinTransaction);
+        const type = "OUT";
+
+        expect(optimistic).toEqual({
+          id: encodeOperationId(account.id, "", type),
+          hash: "",
+          type,
+          value: coinTransaction.amount.plus(estimatedFees),
+          fee: estimatedFees,
+          blockHash: null,
+          blockHeight: null,
+          senders: [account.freshAddress],
+          recipients: [coinTransaction.recipient],
+          accountId: account.id,
+          transactionSequenceNumber: 0,
+          date: expect.any(Date),
+          extra: {},
+        });
+      });
+
+      it("should create a token optimistic transaction waiting for the broadcast to be completed", () => {
+        const tokenTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: tokenAccount.id,
+          recipient: "0x51DF0aF74a0DBae16cB845B46dAF2a35cB1D4168", // michel.eth
+          data: Buffer.from(
+            "a9059cbb00000000000000000000000059569e96d0e3d9728dc07bf5c1443809e6f237fd0000000000000000000000000000000000000000000000000c06701668d322ac",
+            "hex"
+          ),
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(60000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+        const estimatedFees = getEstimatedFees(tokenTransaction);
+        const optimistic = buildOptimisticOperation(account, tokenTransaction);
+
+        expect(optimistic).toEqual({
+          id: encodeOperationId(account.id, "", "FEES"),
+          hash: "",
+          type: "FEES",
+          value: estimatedFees,
+          fee: estimatedFees,
+          blockHash: null,
+          blockHeight: null,
+          senders: [account.freshAddress],
+          recipients: [tokenCurrency.contractAddress],
+          accountId: account.id,
+          transactionSequenceNumber: 0,
+          date: expect.any(Date),
+          subOperations: [
+            {
+              id: encodeOperationId(tokenAccount.id, "", "OUT"),
+              hash: "",
+              type: "OUT",
+              value: tokenTransaction.amount,
+              fee: estimatedFees,
+              blockHash: null,
+              blockHeight: null,
+              senders: [account.freshAddress],
+              recipients: [tokenTransaction.recipient],
+              accountId: tokenAccount.id,
+              transactionSequenceNumber: 0,
+              date: expect.any(Date),
+              contract: tokenAccount.token.contractAddress,
+              extra: {},
+            },
+          ],
+          extra: {},
+        });
+      });
+
+      it("should create a token optimistic transaction with useAllAmount waiting for the broadcast to be completed", () => {
+        const tokenTransaction: EvmTransaction = {
+          amount: new BigNumber(0),
+          useAllAmount: true,
+          subAccountId: tokenAccount.id,
+          recipient: "0x51DF0aF74a0DBae16cB845B46dAF2a35cB1D4168", // michel.eth
+          data: Buffer.from(
+            "a9059cbb00000000000000000000000059569e96d0e3d9728dc07bf5c1443809e6f237fd0000000000000000000000000000000000000000000000000c06701668d322ac",
+            "hex"
+          ),
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(60000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+        const estimatedFees = getEstimatedFees(tokenTransaction);
+        const optimistic = buildOptimisticOperation(account, tokenTransaction);
+
+        expect(optimistic).toEqual({
+          id: encodeOperationId(account.id, "", "FEES"),
+          hash: "",
+          type: "FEES",
+          value: estimatedFees,
+          fee: estimatedFees,
+          blockHash: null,
+          blockHeight: null,
+          senders: [account.freshAddress],
+          recipients: [tokenCurrency.contractAddress],
+          accountId: account.id,
+          transactionSequenceNumber: 0,
+          date: expect.any(Date),
+          subOperations: [
+            {
+              id: encodeOperationId(tokenAccount.id, "", "OUT"),
+              hash: "",
+              type: "OUT",
+              value: account.subAccounts?.[0]?.balance || new BigNumber(150),
+              fee: estimatedFees,
+              blockHash: null,
+              blockHeight: null,
+              senders: [account.freshAddress],
+              recipients: [tokenTransaction.recipient],
+              accountId: tokenAccount.id,
+              transactionSequenceNumber: 0,
+              date: expect.any(Date),
+              contract: tokenAccount.token.contractAddress,
+              extra: {},
+            },
+          ],
+          extra: {},
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,52 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { createTransaction } from "../createTransaction";
+import { makeAccount } from "../testUtils";
+
+const currencyWithChainId = getCryptoCurrencyById("ethereum");
+const currencyWithoutChainId = {
+  ...currencyWithChainId,
+  ethereumLikeInfo: {},
+} as CryptoCurrency;
+const account1 = makeAccount("0xkvn", currencyWithoutChainId);
+const account2 = makeAccount("0xkvn", currencyWithChainId);
+
+describe("EVM Family", () => {
+  describe("createTransaction.ts", () => {
+    it("should create a valid transaction", () => {
+      const transaction1 = createTransaction(account1);
+      const transaction2 = createTransaction(account2);
+
+      expect(transaction1).toEqual({
+        family: "evm",
+        mode: "send",
+        amount: new BigNumber(0),
+        useAllAmount: false,
+        recipient: "",
+        maxFeePerGas: new BigNumber(0),
+        maxPriorityFeePerGas: new BigNumber(0),
+        gasLimit: new BigNumber(21000),
+        nonce: 1,
+        chainId: 0,
+        feesStrategy: "medium",
+        type: 2,
+      });
+
+      expect(transaction2).toEqual({
+        family: "evm",
+        mode: "send",
+        amount: new BigNumber(0),
+        useAllAmount: false,
+        recipient: "",
+        maxFeePerGas: new BigNumber(0),
+        maxPriorityFeePerGas: new BigNumber(0),
+        gasLimit: new BigNumber(21000),
+        nonce: 1,
+        chainId: 1,
+        feesStrategy: "medium",
+        type: 2,
+      });
+    });
+  });
+});

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

@@ -0,0 +1,245 @@
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import BigNumber from "bignumber.js";
+import getDeviceTransactionConfig from "../deviceTransactionConfig";
+import getTransactionStatus from "../getTransactionStatus";
+import { makeAccount, makeTokenAccount } from "../testUtils";
+import { Transaction as EvmTransaction } from "../types";
+
+const currency = getCryptoCurrencyById("ethereum");
+const tokenCurrency = getTokenById("ethereum/erc20/usd__coin");
+const tokenAccount = makeTokenAccount("0xkvn", tokenCurrency);
+const account = makeAccount("0xkvn", currency, [tokenAccount]);
+
+describe("EVM Family", () => {
+  describe("deviceTransactionConfig.ts", () => {
+    describe("getDeviceTransactionConfig", () => {
+      it("should return the right fields and infos for a coin transaction without mode'", async () => {
+        const coinTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: "id",
+          recipient: "0x997e135e96114c0E84FFc58754552368E4abf329", // celinedion.eth
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "unknown mode" as any,
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+
+        const status = await getTransactionStatus(account, coinTransaction);
+
+        expect(
+          getDeviceTransactionConfig({
+            account,
+            parentAccount: undefined,
+            transaction: coinTransaction,
+            status,
+          })
+        ).toEqual([
+          { type: "amount", label: "Amount" },
+          {
+            type: "address",
+            label: "Address",
+            address: coinTransaction.recipient,
+          },
+          {
+            type: "text",
+            label: "Network",
+            value: currency.name.replace("Lite", "").trim(),
+          },
+          { type: "fees", label: "Max fees" },
+        ]);
+      });
+
+      it("should return the right fields and infos for a coin transaction mode 'send'", async () => {
+        const coinTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: "id",
+          recipient: "0x997e135e96114c0E84FFc58754552368E4abf329", // celinedion.eth
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+
+        const status = await getTransactionStatus(account, coinTransaction);
+
+        expect(
+          getDeviceTransactionConfig({
+            account,
+            parentAccount: undefined,
+            transaction: coinTransaction,
+            status,
+          })
+        ).toEqual([
+          { type: "amount", label: "Amount" },
+          {
+            type: "address",
+            label: "Address",
+            address: coinTransaction.recipient,
+          },
+          {
+            type: "text",
+            label: "Network",
+            value: currency.name.replace("Lite", "").trim(),
+          },
+          { type: "fees", label: "Max fees" },
+        ]);
+      });
+
+      it("should return the right fields and infos for a coin transaction mode 'send' with domain", async () => {
+        const coinTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: "id",
+          recipient: "0x997e135e96114c0E84FFc58754552368E4abf329", // celinedion.eth
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+          recipientDomain: {
+            address: "0x123",
+            domain: "vitalik.eth",
+            registry: "ens",
+            type: "forward",
+          },
+        };
+
+        const status = await getTransactionStatus(account, coinTransaction);
+
+        expect(
+          getDeviceTransactionConfig({
+            account,
+            parentAccount: undefined,
+            transaction: coinTransaction,
+            status,
+          })
+        ).toEqual([
+          { type: "amount", label: "Amount" },
+          {
+            type: "text",
+            label: "Domain",
+            value: coinTransaction.recipientDomain?.domain,
+          },
+          {
+            type: "text",
+            label: "Network",
+            value: currency.name.replace("Lite", "").trim(),
+          },
+          { type: "fees", label: "Max fees" },
+        ]);
+      });
+
+      it("should return the right fields and infos for a token transaction mode 'send'", async () => {
+        const tokenTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: tokenAccount.id,
+          recipient: "0x997e135e96114c0E84FFc58754552368E4abf329", // celinedion.eth
+          data: Buffer.from(
+            "a9059cbb00000000000000000000000059569e96d0e3d9728dc07bf5c1443809e6f237fd0000000000000000000000000000000000000000000000000c06701668d322ac",
+            "hex"
+          ),
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+        };
+        const status = await getTransactionStatus(account, tokenTransaction);
+
+        expect(
+          getDeviceTransactionConfig({
+            account: tokenAccount,
+            parentAccount: account,
+            transaction: tokenTransaction,
+            status,
+          })
+        ).toEqual([
+          { type: "amount", label: "Amount" },
+          {
+            type: "address",
+            label: "Address",
+            address: tokenTransaction.recipient,
+          },
+          {
+            type: "text",
+            label: "Network",
+            value: currency.name.replace("Lite", "").trim(),
+          },
+          { type: "fees", label: "Max fees" },
+        ]);
+      });
+
+      it("should return the right fields and infos for a token transaction mode 'send' with domain", async () => {
+        const tokenTransaction: EvmTransaction = {
+          amount: new BigNumber(100),
+          useAllAmount: false,
+          subAccountId: tokenAccount.id,
+          recipient: "0x997e135e96114c0E84FFc58754552368E4abf329", // celinedion.eth
+          data: Buffer.from(
+            "a9059cbb00000000000000000000000059569e96d0e3d9728dc07bf5c1443809e6f237fd0000000000000000000000000000000000000000000000000c06701668d322ac",
+            "hex"
+          ),
+          feesStrategy: "custom",
+          family: "evm",
+          mode: "send",
+          nonce: 0,
+          gasLimit: new BigNumber(21000),
+          chainId: 1,
+          maxFeePerGas: new BigNumber(100),
+          maxPriorityFeePerGas: new BigNumber(100),
+          type: 2,
+          recipientDomain: {
+            address: "0x123",
+            domain: "vitalik.eth",
+            registry: "ens",
+            type: "forward",
+          },
+        };
+        const status = await getTransactionStatus(account, tokenTransaction);
+
+        expect(
+          getDeviceTransactionConfig({
+            account: tokenAccount,
+            parentAccount: account,
+            transaction: tokenTransaction,
+            status,
+          })
+        ).toEqual([
+          { type: "amount", label: "Amount" },
+          {
+            type: "text",
+            label: "Domain",
+            value: tokenTransaction.recipientDomain?.domain,
+          },
+          {
+            type: "text",
+            label: "Network",
+            value: currency.name.replace("Lite", "").trim(),
+          },
+          { type: "fees", label: "Max fees" },
+        ]);
+      });
+    });
+  });
+});