@ledgerhq/coin-filecoin 1.14.1-nightly.20251114023758 → 1.15.0-nightly.20251118023800

package/src/api/api.unit.test.ts

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import network from "@ledgerhq/live-network";
+import { getEnv } from "@ledgerhq/live-env";
+import {
+  fetchBalances,
+  fetchEstimatedFees,
+  fetchBlockHeight,
+  fetchTxs,
+  fetchTxsWithPages,
+  broadcastTx,
+  fetchERC20TokenBalance,
+  fetchERC20TransactionsWithPages,
+} from "./api";
+import {
+  createMockBalanceResponse,
+  createMockEstimatedFeesResponse,
+  createMockTransactionResponse,
+  createMockERC20Transfer,
+  TEST_ADDRESSES,
+  TEST_TRANSACTION_HASHES,
+  TEST_BLOCK_HEIGHTS,
+} from "../test/fixtures";
+
+// Mock dependencies
+jest.mock("@ledgerhq/logs");
+jest.mock("@ledgerhq/live-network/network");
+jest.mock("@ledgerhq/live-env");
+
+const MOCK_API_URL = "https://mock.filecoin.api";
+const mockedNetwork = network as jest.MockedFunction<typeof network>;
+const mockedGetEnv = getEnv as jest.MockedFunction<typeof getEnv>;
+
+describe("Filecoin API", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+    mockedGetEnv.mockReturnValue(MOCK_API_URL);
+  });
+
+  describe("fetchBalances", () => {
+    it("should fetch balance for a given address", async () => {
+      const mockBalance = createMockBalanceResponse({
+        total_balance: "1000000000000000000",
+        spendable_balance: "900000000000000000",
+        locked_balance: "100000000000000000",
+      });
+
+      mockedNetwork.mockResolvedValueOnce({ data: mockBalance, status: 200 });
+
+      const result = await fetchBalances(TEST_ADDRESSES.F1_ADDRESS);
+
+      expect(result).toEqual(mockBalance);
+    });
+  });
+
+  describe("fetchEstimatedFees", () => {
+    it("should fetch estimated fees for a transaction", async () => {
+      const mockFees = createMockEstimatedFeesResponse({
+        gas_limit: 1500000,
+        gas_fee_cap: "150000",
+        gas_premium: "125000",
+        nonce: 5,
+      });
+
+      const request = {
+        from: TEST_ADDRESSES.F1_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F1,
+      };
+
+      mockedNetwork.mockResolvedValueOnce({ data: mockFees, status: 200 });
+
+      const result = await fetchEstimatedFees(request);
+
+      expect(result).toEqual(mockFees);
+    });
+  });
+
+  describe("fetchBlockHeight", () => {
+    it("should fetch current block height", async () => {
+      const mockNetworkStatus = {
+        current_block_identifier: {
+          index: TEST_BLOCK_HEIGHTS.CURRENT,
+          hash: "blockhash123",
+        },
+        genesis_block_identifier: {
+          index: 0,
+          hash: "genesis",
+        },
+        current_block_timestamp: Date.now(),
+      };
+
+      mockedNetwork.mockResolvedValueOnce({ data: mockNetworkStatus, status: 200 });
+
+      const result = await fetchBlockHeight();
+
+      expect(result.current_block_identifier.index).toBe(TEST_BLOCK_HEIGHTS.CURRENT);
+    });
+  });
+
+  describe("fetchTxs", () => {
+    it("should fetch transactions from specific height", async () => {
+      const mockResponse = {
+        txs: [createMockTransactionResponse()],
+        metadata: { limit: 50, offset: 10 },
+      };
+
+      mockedNetwork.mockResolvedValueOnce({ data: mockResponse, status: 200 });
+
+      await fetchTxs(TEST_ADDRESSES.F1_ADDRESS, 2500000, 10, 50);
+
+      expect(mockedNetwork).toHaveBeenCalledWith({
+        method: "GET",
+        url: expect.stringContaining("from_height=2500000&offset=10&limit=50"),
+      });
+    });
+  });
+
+  describe("fetchTxsWithPages", () => {
+    it("should fetch all transactions with multi-page pagination", async () => {
+      const firstPageTxs = Array.from({ length: 1000 }, (_, i) =>
+        createMockTransactionResponse({ hash: `hash_${i}` }),
+      );
+      const secondPageTxs = Array.from({ length: 500 }, (_, i) =>
+        createMockTransactionResponse({ hash: `hash_${1000 + i}` }),
+      );
+
+      mockedNetwork
+        .mockResolvedValueOnce({ data: { txs: firstPageTxs, metadata: {} }, status: 200 })
+        .mockResolvedValueOnce({ data: { txs: secondPageTxs, metadata: {} }, status: 200 });
+
+      const result = await fetchTxsWithPages(TEST_ADDRESSES.F1_ADDRESS, 0);
+
+      expect(result).toHaveLength(1500);
+      expect(mockedNetwork).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("broadcastTx", () => {
+    it("should broadcast a signed transaction", async () => {
+      const mockRequest = {
+        message: {
+          version: 0,
+          to: TEST_ADDRESSES.RECIPIENT_F1,
+          from: TEST_ADDRESSES.F1_ADDRESS,
+          nonce: 5,
+          value: "100000000000000000",
+          gaslimit: 1000000,
+          gasfeecap: "100000",
+          gaspremium: "100000",
+          method: 0,
+          params: "",
+        },
+        signature: {
+          type: 1,
+          data: "signature_data_here",
+        },
+      };
+
+      const mockResponse = {
+        hash: TEST_TRANSACTION_HASHES.VALID,
+      };
+
+      mockedNetwork.mockResolvedValueOnce({ data: mockResponse, status: 200 });
+
+      const result = await broadcastTx(mockRequest);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("fetchERC20TokenBalance", () => {
+    it("should return 0 when no balance data is available", async () => {
+      const mockResponse = {
+        data: [],
+      };
+
+      mockedNetwork.mockResolvedValueOnce({ data: mockResponse, status: 200 });
+
+      const result = await fetchERC20TokenBalance(
+        TEST_ADDRESSES.F4_ADDRESS,
+        TEST_ADDRESSES.ERC20_CONTRACT,
+      );
+
+      expect(result).toBe("0");
+    });
+  });
+
+  describe("fetchERC20TransactionsWithPages", () => {
+    it("should fetch all ERC20 transactions with pagination and sort by timestamp", async () => {
+      const now = Math.floor(Date.now() / 1000);
+
+      const firstPageTxs = Array.from({ length: 1000 }, (_, i) =>
+        createMockERC20Transfer({
+          id: `${i}`,
+          timestamp: now - i,
+        }),
+      );
+
+      const secondPageTxs = Array.from({ length: 300 }, (_, i) =>
+        createMockERC20Transfer({
+          id: `${1000 + i}`,
+          timestamp: now - 1000 - i,
+        }),
+      );
+
+      mockedNetwork
+        .mockResolvedValueOnce({ data: { txs: firstPageTxs }, status: 200 })
+        .mockResolvedValueOnce({ data: { txs: secondPageTxs }, status: 200 });
+
+      const result = await fetchERC20TransactionsWithPages(TEST_ADDRESSES.F4_ADDRESS, 100);
+
+      expect(result).toHaveLength(1300);
+      expect(mockedNetwork).toHaveBeenCalledTimes(2);
+      expect(result[0].timestamp).toBeGreaterThanOrEqual(result[1].timestamp);
+    });
+  });
+});

package/src/common-logic/index.ts

@@ -1,6 +1,4 @@
 export {
-  getUnit,
-  processTxs,
   mapTxToOps,
   getAddress,
   getTxToBroadcast,

package/src/common-logic/utils.ts

@@ -1,98 +1,23 @@
 import { Account, Operation } from "@ledgerhq/types-live";
 import type { Unit } from "@ledgerhq/types-cryptoassets";
-import { log } from "@ledgerhq/logs";
-import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { BigNumber } from "bignumber.js";
 import { BroadcastTransactionRequest, TransactionResponse, TxStatus, Transaction } from "../types";
 import { GetAccountShape, AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { fetchBalances, fetchBlockHeight, fetchTxs } from "../api/api";
+import { fetchBalances, fetchBlockHeight, fetchTxsWithPages } from "../api/api";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import flatMap from "lodash/flatMap";
 import { buildTokenAccounts } from "../erc20/tokenAccounts";
 
-type TxsById = {
-  [id: string]:
-    | {
-        Send: TransactionResponse;
-        Fee?: TransactionResponse;
-      }
-    | {
-        InvokeContract: TransactionResponse;
-        Fee?: TransactionResponse;
-      };
-};
-
-export const getUnit = () => getCryptoCurrencyById("filecoin").units[0];
-
-export const processTxs = (txs: TransactionResponse[]): TransactionResponse[] => {
-  // Group all tx types related to same tx cid into the same object
-  const txsByTxCid = txs.reduce((txsByTxCidResult: TxsById, currentTx) => {
-    const { hash: txCid, type: txType } = currentTx;
-    const txByType = txsByTxCidResult[txCid] || {};
-    switch (txType) {
-      case "Send":
-        (txByType as { Send: TransactionResponse }).Send = currentTx;
-        break;
-      case "InvokeContract":
-        (txByType as { InvokeContract: TransactionResponse }).InvokeContract = currentTx;
-        break;
-      case "Fee":
-        (txByType as { Fee?: TransactionResponse }).Fee = currentTx;
-        break;
-      default:
-        log("warn", `tx type [${txType}] on tx cid [${txCid}] was not recognized.`);
-        break;
-    }
-
-    txsByTxCidResult[txCid] = txByType;
-    return txsByTxCidResult;
-  }, {});
-
-  // Once all tx types have been grouped, we want to find
-  const processedTxs: TransactionResponse[] = [];
-  for (const txCid in txsByTxCid) {
-    const item = txsByTxCid[txCid];
-    const feeTx = item.Fee;
-    let mainTx: TransactionResponse | undefined;
-    if ("Send" in item) {
-      mainTx = item.Send;
-    } else if ("InvokeContract" in item) {
-      mainTx = item.InvokeContract;
-    } else {
-      log(
-        "warn",
-        `unexpected tx type, tx with cid [${txCid}] and payload [${JSON.stringify(item)}]`,
-      );
-    }
-
-    if (!mainTx) {
-      if (feeTx) {
-        log("warn", `feeTx [${feeTx.hash}] found without a mainTx linked to it.`);
-      }
-
-      continue;
-    }
-
-    if (feeTx) {
-      mainTx.fee = feeTx.amount;
-    }
-
-    processedTxs.push(mainTx);
-  }
-
-  return processedTxs;
-};
-
 export const mapTxToOps =
   (accountId: string, { address }: AccountShapeInfo) =>
   (tx: TransactionResponse): Operation[] => {
-    const { to, from, hash, timestamp, amount, fee, status } = tx;
+    const { to, from, hash, timestamp, amount, fee_data, status } = tx;
+
     const ops: Operation[] = [];
     const date = new Date(timestamp * 1000);
-    const value = parseCurrencyUnit(getUnit(), amount.toString());
-    const feeToUse = parseCurrencyUnit(getUnit(), (fee || 0).toString());
+    const value = new BigNumber(amount);
+    const feeToUse = new BigNumber(fee_data?.TotalCost || 0);
 
     const isSending = address === from;
     const isReceiving = address === to;
@@ -186,7 +111,11 @@ export const getTxToBroadcast = (
 };
 
 export const getAccountShape: GetAccountShape = async info => {
-  const { address, currency, derivationMode } = info;
+  const { address, currency, derivationMode, initialAccount } = info;
+
+  const blockSafeDelta = 1200;
+  let lastHeight = (initialAccount?.blockHeight ?? 0) - blockSafeDelta;
+  if (lastHeight < 0) lastHeight = 0;
 
   const accountId = encodeAccountId({
     type: "js",
@@ -196,21 +125,21 @@ export const getAccountShape: GetAccountShape = async info => {
     derivationMode,
   });
 
-  const blockHeight = await fetchBlockHeight();
-  const balance = await fetchBalances(address);
-  const rawTxs = await fetchTxs(address);
-  const tokenAccounts = await buildTokenAccounts(address, accountId, info.initialAccount);
-  const operations = flatMap(processTxs(rawTxs), mapTxToOps(accountId, info)).sort(
-    (a, b) => b.date.getTime() - a.date.getTime(),
-  );
+  const [blockHeight, balance, rawTxs, tokenAccounts] = await Promise.all([
+    fetchBlockHeight(),
+    fetchBalances(address),
+    fetchTxsWithPages(address, lastHeight),
+    buildTokenAccounts(address, lastHeight, accountId, info.initialAccount),
+  ]);
 
   const result: Partial<Account> = {
     id: accountId,
     subAccounts: tokenAccounts,
     balance: new BigNumber(balance.total_balance),
     spendableBalance: new BigNumber(balance.spendable_balance),
-    operations,
-    operationsCount: operations.length,
+    operations: flatMap(rawTxs, mapTxToOps(accountId, info)).sort(
+      (a, b) => b.date.getTime() - a.date.getTime(),
+    ),
     blockHeight: blockHeight.current_block_identifier.index,
   };
   return result;