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

package/src/common-logic/utils.unit.test.ts

@@ -0,0 +1,429 @@
+import {
+  mapTxToOps,
+  getAddress,
+  getTxToBroadcast,
+  getAccountShape,
+  getSubAccount,
+  valueFromUnit,
+} from "./utils";
+import {
+  createMockAccount,
+  createMockTransactionResponse,
+  createMockOperation,
+  createMockTransaction,
+  TEST_ADDRESSES,
+  createMockBalanceResponse,
+  createMockTokenAccount,
+  TEST_BLOCK_HEIGHTS,
+} from "../test/fixtures";
+import { TxStatus } from "../types";
+import BigNumber from "bignumber.js";
+import { DerivationMode } from "@ledgerhq/types-live";
+import * as api from "../api/api";
+import * as tokenAccounts from "../erc20/tokenAccounts";
+
+// Mock API and token account modules
+jest.mock("../api/api");
+jest.mock("../erc20/tokenAccounts");
+
+describe("common-logic/utils", () => {
+  describe("mapTxToOps", () => {
+    const createAccountShapeInfo = (address: string) => ({
+      address,
+      currency: createMockAccount().currency,
+      index: 0,
+      derivationPath: "44'/461'/0'/0/0",
+      derivationMode: "" as DerivationMode,
+    });
+
+    it("should convert send transaction to OUT operation", () => {
+      const account = createMockAccount({
+        freshAddress: TEST_ADDRESSES.F1_ADDRESS,
+      });
+
+      const tx = createMockTransactionResponse({
+        from: TEST_ADDRESSES.F1_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F1,
+        amount: "100000000000000000",
+        status: TxStatus.Ok,
+      });
+
+      const mapper = mapTxToOps(account.id, createAccountShapeInfo(TEST_ADDRESSES.F1_ADDRESS));
+      const ops = mapper(tx);
+
+      expect(ops).toHaveLength(1);
+      expect(ops[0].type).toBe("OUT");
+      expect(ops[0].value.gt(new BigNumber("100000000000000000"))).toBe(true); // includes fees
+      expect(ops[0].hasFailed).toBe(false);
+    });
+
+    it("should convert receive transaction to IN operation", () => {
+      const account = createMockAccount({
+        freshAddress: TEST_ADDRESSES.RECIPIENT_F1,
+      });
+
+      const tx = createMockTransactionResponse({
+        from: TEST_ADDRESSES.F1_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F1,
+        amount: "100000000000000000",
+      });
+
+      const mapper = mapTxToOps(account.id, createAccountShapeInfo(TEST_ADDRESSES.RECIPIENT_F1));
+      const ops = mapper(tx);
+
+      expect(ops).toHaveLength(1);
+      expect(ops[0].type).toBe("IN");
+      expect(ops[0].value.isEqualTo(new BigNumber("100000000000000000"))).toBe(true);
+    });
+
+    it("should handle zero amount transaction as FEES", () => {
+      const account = createMockAccount({
+        freshAddress: TEST_ADDRESSES.F1_ADDRESS,
+      });
+
+      const tx = createMockTransactionResponse({
+        from: TEST_ADDRESSES.F1_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F1,
+        amount: "0",
+      });
+
+      const mapper = mapTxToOps(account.id, createAccountShapeInfo(TEST_ADDRESSES.F1_ADDRESS));
+      const ops = mapper(tx);
+
+      expect(ops).toHaveLength(1);
+      expect(ops[0].type).toBe("FEES");
+    });
+
+    it("should mark failed transactions", () => {
+      const account = createMockAccount({
+        freshAddress: TEST_ADDRESSES.F1_ADDRESS,
+      });
+
+      const tx = createMockTransactionResponse({
+        from: TEST_ADDRESSES.F1_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F1,
+        status: "Fail",
+      });
+
+      const mapper = mapTxToOps(account.id, createAccountShapeInfo(TEST_ADDRESSES.F1_ADDRESS));
+      const ops = mapper(tx);
+
+      expect(ops[0].hasFailed).toBe(true);
+    });
+
+    it("should handle self-transfer (both send and receive)", () => {
+      const account = createMockAccount({
+        freshAddress: TEST_ADDRESSES.F1_ADDRESS,
+      });
+
+      const tx = createMockTransactionResponse({
+        from: TEST_ADDRESSES.F1_ADDRESS,
+        to: TEST_ADDRESSES.F1_ADDRESS,
+        amount: "100000000000000000",
+      });
+
+      const mapper = mapTxToOps(account.id, createAccountShapeInfo(TEST_ADDRESSES.F1_ADDRESS));
+      const ops = mapper(tx);
+
+      expect(ops).toHaveLength(2);
+      expect(ops.some(op => op.type === "OUT")).toBe(true);
+      expect(ops.some(op => op.type === "IN")).toBe(true);
+    });
+  });
+
+  describe("getAddress", () => {
+    it("should extract address and derivation path from account", () => {
+      const account = createMockAccount({
+        freshAddress: TEST_ADDRESSES.F1_ADDRESS,
+        freshAddressPath: "44'/461'/0'/0/0",
+      });
+
+      const result = getAddress(account);
+
+      expect(result.address).toBe(TEST_ADDRESSES.F1_ADDRESS);
+      expect(result.derivationPath).toBe("44'/461'/0'/0/0");
+    });
+  });
+
+  describe("getTxToBroadcast", () => {
+    it("should format transaction for broadcasting", () => {
+      const account = createMockAccount();
+      const transaction = createMockTransaction();
+      const operation = createMockOperation(account, transaction);
+
+      const rawData = {
+        sender: TEST_ADDRESSES.F1_ADDRESS,
+        recipient: TEST_ADDRESSES.RECIPIENT_F1,
+        gasLimit: new BigNumber(1000000),
+        gasFeeCap: new BigNumber("100000"),
+        gasPremium: new BigNumber("100000"),
+        method: 0,
+        version: 0,
+        nonce: 5,
+        signatureType: 1,
+        params: "",
+        value: "100000000000000000",
+      };
+
+      const result = getTxToBroadcast(operation, "signature_data", rawData);
+
+      expect(result.message.from).toBe(TEST_ADDRESSES.F1_ADDRESS);
+      expect(result.message.to).toBe(TEST_ADDRESSES.RECIPIENT_F1);
+      expect(result.message.gaslimit).toBe(1000000);
+      expect(result.message.gasfeecap).toBe("100000");
+      expect(result.message.gaspremium).toBe("100000");
+      expect(result.message.nonce).toBe(5);
+      expect(result.signature.type).toBe(1);
+      expect(result.signature.data).toBe("signature_data");
+    });
+
+    it("should handle ERC20 contract calls with params", () => {
+      const operation = createMockOperation(createMockAccount(), createMockTransaction());
+
+      const rawData = {
+        sender: TEST_ADDRESSES.F4_ADDRESS,
+        recipient: TEST_ADDRESSES.ERC20_CONTRACT,
+        gasLimit: new BigNumber(2000000),
+        gasFeeCap: new BigNumber("200000"),
+        gasPremium: new BigNumber("150000"),
+        method: 3844450837,
+        version: 0,
+        nonce: 10,
+        signatureType: 1,
+        params: "base64encodedparams",
+        value: "0",
+      };
+
+      const result = getTxToBroadcast(operation, "sig", rawData);
+
+      expect(result.message.params).toBe("base64encodedparams");
+      expect(result.message.method).toBe(3844450837);
+      expect(result.message.value).toBe("0");
+    });
+  });
+
+  describe("getAccountShape", () => {
+    const mockedFetchBlockHeight = api.fetchBlockHeight as jest.MockedFunction<
+      typeof api.fetchBlockHeight
+    >;
+    const mockedFetchBalances = api.fetchBalances as jest.MockedFunction<typeof api.fetchBalances>;
+    const mockedFetchTxsWithPages = api.fetchTxsWithPages as jest.MockedFunction<
+      typeof api.fetchTxsWithPages
+    >;
+    const mockedBuildTokenAccounts = tokenAccounts.buildTokenAccounts as jest.MockedFunction<
+      typeof tokenAccounts.buildTokenAccounts
+    >;
+
+    const mockSyncConfig = {
+      paginationConfig: {},
+      blacklistedTokenIds: [],
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it("should fetch and build account shape with balances and token accounts", async () => {
+      const mockAccount = createMockAccount({
+        freshAddress: TEST_ADDRESSES.F1_ADDRESS,
+        blockHeight: TEST_BLOCK_HEIGHTS.CURRENT,
+      });
+
+      const mockBalance = createMockBalanceResponse({
+        total_balance: "1000000000000000000",
+        spendable_balance: "900000000000000000",
+      });
+
+      const mockBlockHeight = {
+        current_block_identifier: {
+          index: TEST_BLOCK_HEIGHTS.CURRENT,
+          hash: "current_block_hash",
+        },
+        genesis_block_identifier: {
+          index: 0,
+          hash: "genesis",
+        },
+        current_block_timestamp: Date.now(),
+      };
+
+      const mockTxs = [
+        createMockTransactionResponse({
+          from: TEST_ADDRESSES.F1_ADDRESS,
+          to: TEST_ADDRESSES.RECIPIENT_F1,
+        }),
+      ];
+
+      const mockParentAccount = createMockAccount();
+      const mockTokenAccounts = [
+        createMockTokenAccount(mockParentAccount, {
+          balance: new BigNumber("5000000000000000000"),
+        }),
+      ];
+
+      mockedFetchBlockHeight.mockResolvedValue(mockBlockHeight);
+      mockedFetchBalances.mockResolvedValue(mockBalance);
+      mockedFetchTxsWithPages.mockResolvedValue(mockTxs);
+      mockedBuildTokenAccounts.mockResolvedValue(mockTokenAccounts);
+
+      const info = {
+        address: TEST_ADDRESSES.F1_ADDRESS,
+        currency: mockAccount.currency,
+        derivationMode: "" as DerivationMode,
+        initialAccount: mockAccount,
+        index: 0,
+        derivationPath: "44'/461'/0'/0/0",
+      };
+
+      const result = await getAccountShape(info, mockSyncConfig);
+
+      expect(result.balance?.isEqualTo(new BigNumber("1000000000000000000"))).toBe(true);
+      expect(result.spendableBalance?.isEqualTo(new BigNumber("900000000000000000"))).toBe(true);
+      expect(result.blockHeight).toBe(TEST_BLOCK_HEIGHTS.CURRENT);
+      expect(result.subAccounts).toEqual(mockTokenAccounts);
+      expect(result.operations).toBeDefined();
+    });
+
+    it("should handle block height safe delta correctly", async () => {
+      const mockAccount = createMockAccount({
+        blockHeight: 500, // Less than blockSafeDelta (1200)
+      });
+
+      const mockBalance = createMockBalanceResponse();
+      const mockBlockHeight = {
+        current_block_identifier: {
+          index: TEST_BLOCK_HEIGHTS.CURRENT,
+          hash: "hash",
+        },
+        genesis_block_identifier: {
+          index: 0,
+          hash: "genesis",
+        },
+        current_block_timestamp: Date.now(),
+      };
+
+      mockedFetchBlockHeight.mockResolvedValue(mockBlockHeight);
+      mockedFetchBalances.mockResolvedValue(mockBalance);
+      mockedFetchTxsWithPages.mockResolvedValue([]);
+      mockedBuildTokenAccounts.mockResolvedValue([]);
+
+      const info = {
+        address: TEST_ADDRESSES.F1_ADDRESS,
+        currency: mockAccount.currency,
+        derivationMode: "" as DerivationMode,
+        initialAccount: mockAccount,
+        index: 0,
+        derivationPath: "44'/461'/0'/0/0",
+      };
+
+      await getAccountShape(info, mockSyncConfig);
+
+      // Should call fetchTxsWithPages with lastHeight = 0 (not negative)
+      expect(mockedFetchTxsWithPages).toHaveBeenCalledWith(TEST_ADDRESSES.F1_ADDRESS, 0);
+    });
+
+    it("should sort operations by date descending", async () => {
+      const now = Math.floor(Date.now() / 1000);
+      const mockBalance = createMockBalanceResponse();
+      const mockBlockHeight = {
+        current_block_identifier: {
+          index: TEST_BLOCK_HEIGHTS.CURRENT,
+          hash: "hash",
+        },
+        genesis_block_identifier: {
+          index: 0,
+          hash: "genesis",
+        },
+        current_block_timestamp: Date.now(),
+      };
+
+      const mockTxs = [
+        createMockTransactionResponse({
+          hash: "tx1",
+          timestamp: now - 1000,
+          from: TEST_ADDRESSES.F1_ADDRESS,
+          to: TEST_ADDRESSES.RECIPIENT_F1,
+        }),
+        createMockTransactionResponse({
+          hash: "tx2",
+          timestamp: now - 500,
+          from: TEST_ADDRESSES.F1_ADDRESS,
+          to: TEST_ADDRESSES.RECIPIENT_F1,
+        }),
+        createMockTransactionResponse({
+          hash: "tx3",
+          timestamp: now - 2000,
+          from: TEST_ADDRESSES.F1_ADDRESS,
+          to: TEST_ADDRESSES.RECIPIENT_F1,
+        }),
+      ];
+
+      mockedFetchBlockHeight.mockResolvedValue(mockBlockHeight);
+      mockedFetchBalances.mockResolvedValue(mockBalance);
+      mockedFetchTxsWithPages.mockResolvedValue(mockTxs);
+      mockedBuildTokenAccounts.mockResolvedValue([]);
+
+      const info = {
+        address: TEST_ADDRESSES.F1_ADDRESS,
+        currency: createMockAccount().currency,
+        derivationMode: "" as DerivationMode,
+        initialAccount: undefined,
+        index: 0,
+        derivationPath: "44'/461'/0'/0/0",
+      };
+
+      const result = await getAccountShape(info, mockSyncConfig);
+
+      // Operations should be sorted newest first
+      expect(result.operations?.[0].hash).toBe("tx2");
+      expect(result.operations?.[1].hash).toBe("tx1");
+      expect(result.operations?.[2].hash).toBe("tx3");
+    });
+  });
+
+  describe("getSubAccount", () => {
+    it("should return sub account when transaction has subAccountId", () => {
+      const account = createMockAccount();
+      const subAccount = createMockTokenAccount(account, {
+        id: "subaccount123",
+      });
+
+      const accountWithSub = createMockAccount({
+        subAccounts: [subAccount],
+      });
+
+      const transaction = createMockTransaction({
+        subAccountId: "subaccount123",
+      });
+
+      const result = getSubAccount(accountWithSub, transaction);
+
+      expect(result).toEqual(subAccount);
+    });
+  });
+
+  describe("valueFromUnit", () => {
+    it("should convert value with unit magnitude", () => {
+      const unit = {
+        name: "FIL",
+        code: "FIL",
+        magnitude: 18,
+      };
+
+      const result = valueFromUnit(new BigNumber(1), unit);
+
+      expect(result.isEqualTo(new BigNumber("1000000000000000000"))).toBe(true);
+    });
+
+    it("should handle decimal values", () => {
+      const unit = {
+        name: "FIL",
+        code: "FIL",
+        magnitude: 18,
+      };
+
+      const result = valueFromUnit(new BigNumber("0.5"), unit);
+
+      expect(result.isEqualTo(new BigNumber("500000000000000000"))).toBe(true);
+    });
+  });
+});

package/src/erc20/tokenAccounts.ts

@@ -1,6 +1,6 @@
 import cbor from "@zondax/cbor";
 import { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
-import { fetchERC20TokenBalance, fetchERC20Transactions } from "../api";
+import { fetchERC20TokenBalance, fetchERC20TransactionsWithPages } from "../api";
 import invariant from "invariant";
 import { ERC20Transfer, TxStatus } from "../types";
 import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
@@ -12,19 +12,17 @@ import { convertAddressFilToEth } from "../network";
 import { ethers } from "ethers";
 import contractABI from "./ERC20.json";
 import { RecipientRequired } from "@ledgerhq/errors";
-import { Unit } from "@ledgerhq/types-cryptoassets";
 import { AccountType } from "../bridge/utils";
-import { valueFromUnit } from "../common-logic/utils";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 
 export const erc20TxnToOperation = (
   tx: ERC20Transfer,
   address: string,
   accountId: string,
-  unit: Unit,
 ): Operation[] => {
   try {
     const { to, from, timestamp, tx_hash, tx_cid, amount, height, status } = tx;
-    const value = valueFromUnit(new BigNumber(amount), unit);
+    const txAmount = new BigNumber(amount);
 
     const isSending = address.toLowerCase() === from.toLowerCase();
     const isReceiving = address.toLowerCase() === to.toLowerCase();
@@ -41,7 +39,7 @@ export const erc20TxnToOperation = (
         id: encodeOperationId(accountId, hash, "OUT"),
         hash,
         type: "OUT",
-        value: value,
+        value: txAmount,
         fee,
         blockHeight: height,
         blockHash: "",
@@ -59,7 +57,7 @@ export const erc20TxnToOperation = (
         id: encodeOperationId(accountId, hash, "IN"),
         hash,
         type: "IN",
-        value,
+        value: txAmount,
         fee,
         blockHeight: height,
         blockHash: "",
@@ -83,51 +81,71 @@ export const erc20TxnToOperation = (
 
 export async function buildTokenAccounts(
   filAddr: string,
+  lastHeight: number,
   parentAccountId: string,
   initialAccount?: Account,
 ): Promise<TokenAccount[]> {
   try {
-    const transfers = await fetchERC20Transactions(filAddr);
-    const transfersUntangled: { [addr: string]: ERC20Transfer[] } = transfers.reduce(
-      (prev: { [addr: string]: ERC20Transfer[] }, curr: ERC20Transfer) => {
-        curr.contract_address = curr.contract_address.toLowerCase();
-        if (prev[curr.contract_address]) {
-          prev[curr.contract_address] = [...prev[curr.contract_address], curr];
-        } else {
-          prev[curr.contract_address] = [curr];
+    const transfers = await fetchERC20TransactionsWithPages(filAddr, lastHeight);
+
+    if (!transfers.length) {
+      return initialAccount?.subAccounts ?? [];
+    }
+
+    // Group transfers by contract address (normalized to lowercase)
+    const transfersByContract = transfers.reduce<Record<string, ERC20Transfer[]>>(
+      (acc, transfer) => {
+        const contractAddr = transfer.contract_address.toLowerCase();
+        transfer.contract_address = contractAddr;
+
+        if (!acc[contractAddr]) {
+          acc[contractAddr] = [];
         }
-        return prev;
+        acc[contractAddr].push(transfer);
+        return acc;
       },
       {},
     );
 
-    const subs: TokenAccount[] = [];
-    for (const [cAddr, txns] of Object.entries(transfersUntangled)) {
-      const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(cAddr, "filecoin");
+    // Create lookup map for existing sub-accounts
+    const existingSubAccounts = new Map(
+      initialAccount?.subAccounts?.map(sa => [sa.token.contractAddress.toLowerCase(), sa]) ?? [],
+    );
+
+    // Track which existing accounts we've processed
+    const processedContracts = new Set<string>();
+    const tokenAccounts: TokenAccount[] = [];
+
+    // Process accounts with new transfers
+    for (const [contractAddr, txns] of Object.entries(transfersByContract)) {
+      processedContracts.add(contractAddr);
+
+      const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+        contractAddr,
+        "filecoin",
+      );
       if (!token) {
-        log("error", `filecoin token not found, addr: ${cAddr}`);
+        log("error", `filecoin token not found, addr: ${contractAddr}`);
         continue;
       }
 
-      const balance = await fetchERC20TokenBalance(filAddr, cAddr);
-      const bnBalance = new BigNumber(balance.toString());
+      const balance = await fetchERC20TokenBalance(filAddr, contractAddr);
+      const bnBalance = new BigNumber(balance);
       const tokenAccountId = encodeTokenAccountId(parentAccountId, token);
 
       const operations = txns
-        .flatMap(txn => erc20TxnToOperation(txn, filAddr, tokenAccountId, token.units[0]))
+        .flatMap(txn => erc20TxnToOperation(txn, filAddr, tokenAccountId))
         .flat()
         .sort((a, b) => b.date.getTime() - a.date.getTime());
 
+      // Skip if no operations and zero balance
       if (operations.length === 0 && bnBalance.isZero()) {
         continue;
       }
 
-      const maybeExistingSubAccount =
-        initialAccount &&
-        initialAccount.subAccounts &&
-        initialAccount.subAccounts.find(a => a.id === tokenAccountId);
+      const existingAccount = existingSubAccounts.get(contractAddr);
 
-      const sub: TokenAccount = {
+      const tokenAccount: TokenAccount = {
         type: AccountType.TokenAccount,
         id: tokenAccountId,
         parentId: parentAccountId,
@@ -135,17 +153,24 @@ export async function buildTokenAccounts(
         balance: bnBalance,
         spendableBalance: bnBalance,
         operationsCount: txns.length,
-        operations,
-        pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
-        creationDate: operations.length > 0 ? operations[0].date : new Date(),
-        swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
+        operations: mergeOps(existingAccount?.operations ?? [], operations),
+        pendingOperations: existingAccount?.pendingOperations ?? [],
+        creationDate: operations[operations.length - 1]?.date ?? new Date(),
+        swapHistory: existingAccount?.swapHistory ?? [],
         balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
       };
 
-      subs.push(sub);
+      tokenAccounts.push(tokenAccount);
+    }
+
+    // Add existing accounts that didn't have new transfers
+    for (const [contractAddr, existingAccount] of existingSubAccounts) {
+      if (!processedContracts.has(contractAddr)) {
+        tokenAccounts.push(existingAccount);
+      }
     }
 
-    return subs;
+    return tokenAccounts;
   } catch (e) {
     log("error", "filecoin error building token accounts", e);
     return [];

package/src/erc20/tokenAccounts.unit.test.ts

@@ -0,0 +1,73 @@
+import { erc20TxnToOperation } from "./tokenAccounts";
+import { createMockERC20Transfer, TEST_ADDRESSES } from "../test/fixtures";
+import BigNumber from "bignumber.js";
+import { TxStatus } from "../types";
+
+jest.mock("@ledgerhq/logs", () => ({
+  log: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-framework/crypto-assets/index", () => ({
+  getCryptoAssetsStore: () => ({
+    findTokenByAddress: jest.fn(),
+  }),
+}));
+
+describe("erc20/tokenAccounts", () => {
+  describe("erc20TxnToOperation", () => {
+    it("should convert ERC20 send transaction to OUT operation", () => {
+      const tx = createMockERC20Transfer({
+        from: TEST_ADDRESSES.F4_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F4,
+        amount: "1000000000000000000",
+        status: TxStatus.Ok,
+      });
+
+      const accountId = "accountId123";
+      const ops = erc20TxnToOperation(tx, TEST_ADDRESSES.F4_ADDRESS, accountId);
+
+      expect(ops).toHaveLength(1);
+      expect(ops[0].type).toBe("OUT");
+      expect(ops[0].value.isEqualTo(new BigNumber("1000000000000000000"))).toBe(true);
+      expect(ops[0].accountId).toBe(accountId);
+    });
+
+    it("should convert ERC20 receive transaction to IN operation", () => {
+      const tx = createMockERC20Transfer({
+        from: TEST_ADDRESSES.F4_ADDRESS,
+        to: TEST_ADDRESSES.RECIPIENT_F4,
+        amount: "500000000000000000",
+      });
+
+      const accountId = "accountId123";
+      const ops = erc20TxnToOperation(tx, TEST_ADDRESSES.RECIPIENT_F4, accountId);
+
+      expect(ops).toHaveLength(1);
+      expect(ops[0].type).toBe("IN");
+      expect(ops[0].value.isEqualTo(new BigNumber("500000000000000000"))).toBe(true);
+    });
+
+    it("should handle failed transaction", () => {
+      const tx = createMockERC20Transfer({
+        status: "Fail",
+      });
+
+      const ops = erc20TxnToOperation(tx, TEST_ADDRESSES.F4_ADDRESS, "accountId");
+
+      expect(ops[0].hasFailed).toBe(true);
+    });
+
+    it("should handle self-transfer (both send and receive)", () => {
+      const tx = createMockERC20Transfer({
+        from: TEST_ADDRESSES.F4_ADDRESS,
+        to: TEST_ADDRESSES.F4_ADDRESS,
+      });
+
+      const ops = erc20TxnToOperation(tx, TEST_ADDRESSES.F4_ADDRESS, "accountId");
+
+      expect(ops).toHaveLength(2);
+      expect(ops.some(op => op.type === "OUT")).toBe(true);
+      expect(ops.some(op => op.type === "IN")).toBe(true);
+    });
+  });
+});