@ledgerhq/coin-hedera 1.15.0-nightly.20251126023856 → 1.15.0-nightly.20251126160702

package/src/bridge/utils.integration.test.ts

@@ -4,20 +4,20 @@ import { setupCalClientStore } from "@ledgerhq/cryptoassets/cal-client/test-help
 import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
 import { estimateFees } from "../logic/estimateFees";
+import { toEVMAddress } from "../logic/utils";
+import { apiClient } from "../network/api";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
-import { getMockedTokenCurrency, getTokenCurrencyFromCAL } from "../test/fixtures/currency.fixture";
-import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
-import { getMockedOperation } from "../test/fixtures/operation.fixture";
-import { getMockedMirrorToken } from "../test/fixtures/mirror.fixture";
-import type { HederaOperationExtra } from "../types";
 import {
-  applyPendingExtras,
-  calculateAmount,
-  getSubAccounts,
-  mergeSubAccounts,
-  patchOperationWithExtra,
-  prepareOperations,
-} from "./utils";
+  getMockedHTSTokenCurrency,
+  getTokenCurrencyFromCAL,
+  getTokenCurrencyFromCALByType,
+} from "../test/fixtures/currency.fixture";
+import { getMockedMirrorToken } from "../test/fixtures/mirror.fixture";
+import { getMockedOperation } from "../test/fixtures/operation.fixture";
+import { getMockedThirdwebTransaction } from "../test/fixtures/thirdweb.fixture";
+import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
+import type { EstimateFeesResult } from "../types";
+import { calculateAmount, getSubAccounts, integrateERC20Operations } from "./utils";
 
 describe("utils", () => {
   beforeAll(() => {
@@ -26,24 +26,30 @@ describe("utils", () => {
   });
 
   describe("calculateAmount", () => {
-    let estimatedFees: Record<"crypto" | "associate", BigNumber>;
+    let estimatedFees: Record<"crypto" | "associate", EstimateFeesResult>;
 
     beforeAll(async () => {
       const mockedAccount = getMockedAccount();
       const [crypto, associate] = await Promise.all([
-        estimateFees(mockedAccount.currency, HEDERA_OPERATION_TYPES.CryptoTransfer),
-        estimateFees(mockedAccount.currency, HEDERA_OPERATION_TYPES.TokenAssociate),
+        estimateFees({
+          currency: mockedAccount.currency,
+          operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+        }),
+        estimateFees({
+          currency: mockedAccount.currency,
+          operationType: HEDERA_OPERATION_TYPES.TokenAssociate,
+        }),
       ]);
 
       estimatedFees = { crypto, associate };
     });
 
-    test("HBAR transfer, useAllAmount = true", async () => {
+    it("HBAR transfer, useAllAmount = true", async () => {
       const mockedAccount = getMockedAccount();
       const mockedTransaction = getMockedTransaction({ useAllAmount: true });
 
-      const amount = mockedAccount.balance.minus(estimatedFees.crypto);
-      const totalSpent = amount.plus(estimatedFees.crypto);
+      const amount = mockedAccount.balance.minus(estimatedFees.crypto.tinybars);
+      const totalSpent = amount.plus(estimatedFees.crypto.tinybars);
 
       const result = await calculateAmount({
         account: mockedAccount,
@@ -53,7 +59,7 @@ describe("utils", () => {
       expect(result).toEqual({ amount, totalSpent });
     });
 
-    test("HBAR transfer, useAllAmount = false", async () => {
+    it("HBAR transfer, useAllAmount = false", async () => {
       const mockedAccount = getMockedAccount();
       const mockedTransaction = getMockedTransaction({
         useAllAmount: false,
@@ -61,7 +67,7 @@ describe("utils", () => {
       });
 
       const amount = mockedTransaction.amount;
-      const totalSpent = amount.plus(estimatedFees.crypto);
+      const totalSpent = amount.plus(estimatedFees.crypto.tinybars);
 
       const result = await calculateAmount({
         account: mockedAccount,
@@ -71,8 +77,8 @@ describe("utils", () => {
       expect(result).toEqual({ amount, totalSpent });
     });
 
-    test("token transfer, useAllAmount = true", async () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("token transfer, useAllAmount = true", async () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
       const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
       const mockedTransaction = getMockedTransaction({
@@ -91,8 +97,8 @@ describe("utils", () => {
       expect(result).toEqual({ amount, totalSpent });
     });
 
-    test("token transfer, useAllAmount = false", async () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("token transfer, useAllAmount = false", async () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
       const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
       const mockedTransaction = getMockedTransaction({
@@ -112,8 +118,8 @@ describe("utils", () => {
       expect(result).toEqual({ amount, totalSpent });
     });
 
-    test("token associate operation uses TokenAssociate fee", async () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("token associate operation uses TokenAssociate fee", async () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
       const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
       const mockedTransaction = getMockedTransaction({
@@ -126,7 +132,7 @@ describe("utils", () => {
       });
 
       const amount = mockedTransaction.amount;
-      const totalSpent = amount.plus(estimatedFees.associate);
+      const totalSpent = amount.plus(estimatedFees.associate.tinybars);
 
       const result = await calculateAmount({
         account: mockedAccount,
@@ -138,7 +144,7 @@ describe("utils", () => {
   });
 
   describe("getSubAccounts", () => {
-    test("returns sub account based on operations and mirror tokens", async () => {
+    it("returns sub account based on operations and mirror tokens", async () => {
       const firstTokenCurrencyFromCAL = getTokenCurrencyFromCAL(0);
       const secondTokenCurrencyFromCAL = getTokenCurrencyFromCAL(1);
       const mockedAccount = getMockedAccount();
@@ -172,215 +178,515 @@ describe("utils", () => {
         accountId: encodeTokenAccountId(mockedAccount.id, secondTokenFromCAL),
       });
 
-      const result = await getSubAccounts(
-        mockedAccount.id,
-        [mockedOperation1, mockedOperation2],
-        [mockedMirrorToken1, mockedMirrorToken2],
-      );
+      const result = await getSubAccounts({
+        ledgerAccountId: mockedAccount.id,
+        latestHTSTokenOperations: [mockedOperation1, mockedOperation2],
+        latestERC20TokenOperations: [],
+        mirrorTokens: [mockedMirrorToken1, mockedMirrorToken2],
+        erc20Tokens: [],
+      });
       const uniqueSubAccountIds = new Set(result.map(sa => sa.id));
 
-      expect(result).toHaveLength(2);
-      // Compare contract address instead of full object since CAL format may differ
-      expect(result[0].token.contractAddress).toBe(firstTokenCurrencyFromCAL.contractAddress);
-      expect(result[1].token.contractAddress).toBe(secondTokenCurrencyFromCAL.contractAddress);
-      expect(result[0].balance).toEqual(new BigNumber(10));
-      expect(result[1].balance).toEqual(new BigNumber(0));
-      expect(result[0].operations).toEqual([mockedOperation1]);
-      expect(result[1].operations).toEqual([mockedOperation2]);
       expect(uniqueSubAccountIds.size).toBe(result.length);
+      expect(result).toHaveLength(2);
+      expect(result).toMatchObject([
+        {
+          token: firstTokenCurrencyFromCAL,
+          balance: new BigNumber(10),
+          operations: [mockedOperation1],
+        },
+        {
+          token: secondTokenCurrencyFromCAL,
+          balance: new BigNumber(0),
+          operations: [mockedOperation2],
+        },
+      ]);
     });
 
-    test("ignores operation if token is not listed in CAL", async () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("ignores operation if token is not listed in CAL", async () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedAccount = getMockedAccount();
       const mockedOperation = getMockedOperation({
         accountId: encodeTokenAccountId(mockedAccount.id, mockedTokenCurrency),
       });
 
-      const result = await getSubAccounts(mockedAccount.id, [mockedOperation], []);
+      const result = await getSubAccounts({
+        ledgerAccountId: mockedAccount.id,
+        latestHTSTokenOperations: [mockedOperation],
+        latestERC20TokenOperations: [],
+        mirrorTokens: [],
+        erc20Tokens: [],
+      });
 
       expect(result).toHaveLength(0);
     });
 
-    test("returns sub account for mirror token with no operations yet (e.g. right after association)", async () => {
+    it("returns sub account for mirror token with no operations yet (e.g. right after association)", async () => {
       const tokenCurrencyFromCAL = getTokenCurrencyFromCAL(0);
       const mockedAccount = getMockedAccount();
-      const mockedMirrorToken = getMockedMirrorToken({
+      const mockedTokenHTS = getMockedMirrorToken({
         token_id: tokenCurrencyFromCAL.contractAddress,
         balance: 42,
       });
 
-      const result = await getSubAccounts(mockedAccount.id, [], [mockedMirrorToken]);
+      const result = await getSubAccounts({
+        ledgerAccountId: mockedAccount.id,
+        latestHTSTokenOperations: [],
+        latestERC20TokenOperations: [],
+        mirrorTokens: [mockedTokenHTS],
+        erc20Tokens: [],
+      });
 
       expect(result).toHaveLength(1);
-      // Compare contract address instead of full object since CAL format may differ
-      expect(result[0].token.contractAddress).toBe(tokenCurrencyFromCAL.contractAddress);
-      expect(result[0].operations).toHaveLength(0);
-      expect(result[0].balance).toEqual(new BigNumber(42));
+      expect(result).toMatchObject([
+        {
+          token: tokenCurrencyFromCAL,
+          operations: [],
+          balance: new BigNumber(42),
+        },
+      ]);
     });
-  });
-
-  describe("prepareOperations", () => {
-    test("links token operation to existing coin operation with matching hash", async () => {
-      const tokenCurrencyFromCAL = getTokenCurrencyFromCAL(0);
-      // Fetch actual token from CAL to ensure we use the correct format
-      const tokenFromCAL = await getCryptoAssetsStore().findTokenByAddressInCurrency(
-        tokenCurrencyFromCAL.contractAddress,
-        "hedera",
-      );
 
-      if (!tokenFromCAL) {
-        throw new Error("Token not found in CAL");
-      }
+    it("returns sub account for erc20 token with no operations yet", async () => {
+      const tokenCurrencyFromCAL = getTokenCurrencyFromCALByType("erc20");
+      const mockedAccount = getMockedAccount();
 
-      const mockedTokenAccount = getMockedTokenAccount(tokenFromCAL);
-      const mockedCoinOperation = getMockedOperation({ hash: "shared" });
-      const mockedTokenOperation = getMockedOperation({
-        hash: "shared",
-        accountId: encodeTokenAccountId(mockedTokenAccount.parentId, tokenFromCAL),
+      const result = await getSubAccounts({
+        ledgerAccountId: mockedAccount.id,
+        latestHTSTokenOperations: [],
+        latestERC20TokenOperations: [],
+        mirrorTokens: [],
+        erc20Tokens: [{ balance: new BigNumber(42), token: tokenCurrencyFromCAL }],
       });
 
-      const result = await prepareOperations([mockedCoinOperation], [mockedTokenOperation]);
-
       expect(result).toHaveLength(1);
-      expect(result[0].subOperations).toEqual([mockedTokenOperation]);
+      expect(result).toMatchObject([
+        {
+          token: tokenCurrencyFromCAL,
+          operations: [],
+          balance: new BigNumber(42),
+        },
+      ]);
     });
+  });
 
-    test("creates NONE coin operation as parent if no coin op with matching hash exists", async () => {
-      const tokenCurrencyFromCAL = getTokenCurrencyFromCAL(0);
-      // Fetch actual token from CAL to ensure we use the correct format
-      const tokenFromCAL = await getCryptoAssetsStore().findTokenByAddressInCurrency(
-        tokenCurrencyFromCAL.contractAddress,
-        "hedera",
-      );
+  describe("integrateERC20Operations", () => {
+    const address = "0.0.12345";
+    const evmAddress = toEVMAddress(address);
+    const ledgerAccountId = `js:2:hedera:${address}:`;
+    const tokenCurrency = getTokenCurrencyFromCALByType("erc20");
 
-      if (!tokenFromCAL) {
-        throw new Error("Token not found in CAL");
-      }
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
 
-      const mockedTokenAccount = getMockedTokenAccount(tokenFromCAL);
-      const mockedOrphanTokenOperation = getMockedOperation({
-        hash: "unknown-hash",
-        accountId: encodeTokenAccountId(mockedTokenAccount.parentId, tokenFromCAL),
+    it("creates new operation for erc20 in transfer", async () => {
+      const mockGetContractCallResult = jest.spyOn(apiClient, "getContractCallResult");
+      const mockFindTransactionByContractCall = jest.spyOn(
+        apiClient,
+        "findTransactionByContractCall",
+      );
+
+      const incomingTxConsensusTimestamp = `1705836000.000000000`;
+      const incomingTxHash = "incoming_erc20";
+      const incomingTxValue = "3000000";
+      const incomingTxFrom = "0xSENDER";
+      const incomingTxTo = evmAddress;
+      const incomingERC20Transaction = getMockedThirdwebTransaction({
+        transactionHash: incomingTxHash,
+        address: tokenCurrency.contractAddress,
+        blockHash: "0xINCOMING_BLOCK",
+        blockNumber: 12345,
+        decoded: {
+          name: "Transfer",
+          signature: "Transfer(address,address,uint256)",
+          params: {
+            from: incomingTxFrom,
+            to: incomingTxTo,
+            value: incomingTxValue,
+          },
+        },
+      });
+      const oldMirrorOperations = [
+        getMockedOperation({
+          hash: "normal_tx",
+          type: "IN",
+          date: new Date("2024-01-20T10:00:00Z"),
+        }),
+      ];
+
+      mockGetContractCallResult.mockResolvedValue({
+        timestamp: incomingTxConsensusTimestamp,
+        contract_id: tokenCurrency.contractAddress,
+      } as any);
+
+      mockFindTransactionByContractCall.mockResolvedValue({
+        transaction_hash: incomingTxHash,
+        consensus_timestamp: incomingTxConsensusTimestamp,
+      } as any);
+
+      const { updatedOperations, newERC20TokenOperations } = await integrateERC20Operations({
+        ledgerAccountId,
+        address,
+        allOperations: oldMirrorOperations,
+        latestERC20Transactions: [incomingERC20Transaction],
+        pendingOperationHashes: new Set(),
+        erc20OperationHashes: new Set(),
       });
 
-      const result = await prepareOperations([], [mockedOrphanTokenOperation]);
-      const noneOp = result.find(op => op.type === "NONE");
+      const incomingOp = updatedOperations.find(op => op.hash === incomingTxHash);
 
-      expect(typeof noneOp).toBe("object");
-      expect(noneOp).not.toBeNull();
-      expect(noneOp?.subOperations?.[0]).toEqual(mockedOrphanTokenOperation);
-      expect(noneOp?.hash).toBe("unknown-hash");
+      expect(incomingOp).toMatchObject({
+        type: "NONE",
+        hash: incomingTxHash,
+        blockHash: incomingERC20Transaction.blockHash,
+      });
+      expect(incomingOp?.subOperations).toHaveLength(1);
+      expect(incomingOp?.subOperations).toMatchObject([
+        {
+          type: "IN",
+          hash: incomingTxHash,
+          blockHash: incomingERC20Transaction.blockHash,
+          standard: "erc20",
+          value: new BigNumber(incomingTxValue),
+          senders: [incomingTxFrom],
+          recipients: [address],
+        },
+      ]);
+      expect(newERC20TokenOperations).toHaveLength(1);
+      expect(newERC20TokenOperations).toMatchObject([incomingOp?.subOperations?.[0]]);
+      expect(updatedOperations).toHaveLength(oldMirrorOperations.length + 1);
     });
-  });
 
-  describe("mergeSubAccounts", () => {
-    test("returns newSubAccounts if no initial account exists", () => {
-      const mockedTokenCurrency1 = getMockedTokenCurrency({ id: "token1" });
-      const mockedTokenCurrency2 = getMockedTokenCurrency({ id: "token2" });
-      const mockedTokenAccount1 = getMockedTokenAccount(mockedTokenCurrency1, { id: "ta1" });
-      const mockedTokenAccount2 = getMockedTokenAccount(mockedTokenCurrency2, { id: "ta2" });
-      const initialAccount = undefined;
-      const newSubAccounts = [mockedTokenAccount1, mockedTokenAccount2];
+    it("creates new operation for erc20 out transfer (not made by user)", async () => {
+      const mockGetContractCallResult = jest.spyOn(apiClient, "getContractCallResult");
+      const mockFindTransactionByContractCall = jest.spyOn(
+        apiClient,
+        "findTransactionByContractCall",
+      );
 
-      const result = mergeSubAccounts(initialAccount, newSubAccounts);
+      const allowanceTxConsensusTimestamp = "1705922400.000000000";
+      const allowanceTxHash = "transfer_by_allowance";
+      const allowanceTxValue = "2000000";
+      const allowanceTxFrom = evmAddress;
+      const allowanceTxTo = "0xRECIPIENT";
+
+      const oldMirrorOperations = [
+        getMockedOperation({
+          hash: "normal_tx",
+          type: "OUT",
+          date: new Date("2024-01-20T10:00:00Z"),
+        }),
+      ];
+
+      const allowanceERC20Transaction = getMockedThirdwebTransaction({
+        transactionHash: allowanceTxHash,
+        address: tokenCurrency.contractAddress,
+        blockHash: "0xALLOWANCE_BLOCK",
+        blockNumber: 12346,
+        decoded: {
+          name: "Transfer",
+          signature: "Transfer(address,address,uint256)",
+          params: {
+            from: allowanceTxFrom,
+            to: allowanceTxTo,
+            value: allowanceTxValue,
+          },
+        },
+      });
 
-      expect(result).toEqual(newSubAccounts);
-    });
+      mockGetContractCallResult.mockResolvedValue({
+        timestamp: allowanceTxConsensusTimestamp,
+        contract_id: tokenCurrency.contractAddress,
+      } as any);
+
+      mockFindTransactionByContractCall.mockResolvedValue({
+        transaction_hash: allowanceTxHash,
+        consensus_timestamp: allowanceTxConsensusTimestamp,
+      } as any);
+
+      const { updatedOperations, newERC20TokenOperations } = await integrateERC20Operations({
+        ledgerAccountId,
+        address,
+        allOperations: oldMirrorOperations,
+        latestERC20Transactions: [allowanceERC20Transaction],
+        pendingOperationHashes: new Set(),
+        erc20OperationHashes: new Set(),
+      });
 
-    test("merges operations and updates only changed fields", () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
-      const existingOperation = getMockedOperation({ id: "op1" });
-      const newOperation = getMockedOperation({ id: "op2" });
-      const newPendingOperation = getMockedOperation({ id: "op3" });
-      const existingTokenAccount = getMockedTokenAccount(mockedTokenCurrency, {
-        id: "tokenaccount",
-        balance: new BigNumber(1000),
-        creationDate: new Date(),
-        operations: [existingOperation],
-        pendingOperations: [],
-      });
-      const updatedTokenAccount = getMockedTokenAccount(mockedTokenCurrency, {
-        id: "tokenaccount",
-        balance: new BigNumber(2000),
-        creationDate: new Date(Date.now() - 24 * 60 * 60 * 1000),
-        operations: [newOperation],
-        pendingOperations: [newPendingOperation],
-      });
-      const mockedAccount = getMockedAccount({ subAccounts: [existingTokenAccount] });
-
-      const result = mergeSubAccounts(mockedAccount, [updatedTokenAccount]);
-      const merged = result[0];
+      const allowanceOp = updatedOperations.find(op => op.hash === allowanceTxHash);
 
-      expect(result).toHaveLength(1);
-      expect(merged.creationDate).toEqual(existingTokenAccount.creationDate);
-      expect(merged.balance).toEqual(new BigNumber(2000));
-      expect(merged.pendingOperations.map(op => op.id)).toEqual(["op3"]);
-      expect(merged.operations.map(op => op.id)).toEqual(["op2", "op1"]);
-      expect(merged.operationsCount).toEqual(2);
+      expect(allowanceOp).toMatchObject({
+        type: "FEES",
+        hash: allowanceTxHash,
+        blockHash: allowanceERC20Transaction.blockHash,
+        standard: "erc20",
+      });
+      expect(allowanceOp?.subOperations).toHaveLength(1);
+      expect(allowanceOp?.subOperations).toMatchObject([
+        {
+          type: "OUT",
+          hash: allowanceTxHash,
+          blockHash: allowanceERC20Transaction.blockHash,
+          standard: "erc20",
+          value: new BigNumber(allowanceTxValue),
+          senders: [address],
+          recipients: [allowanceTxTo],
+        },
+      ]);
+      expect(newERC20TokenOperations).toHaveLength(1);
+      expect(newERC20TokenOperations).toMatchObject([allowanceOp?.subOperations?.[0]]);
+      expect(updatedOperations).toHaveLength(oldMirrorOperations.length + 1);
     });
 
-    test("adds new sub accounts that are not present in initial account", () => {
-      const existingToken = getMockedTokenCurrency({ id: "token1" });
-      const newToken = getMockedTokenCurrency({ id: "token2" });
-      const existingTokenAccount = getMockedTokenAccount(existingToken, { id: "ta1" });
-      const newTokenAccount = getMockedTokenAccount(newToken, { id: "ta2" });
-      const mockedAccount = getMockedAccount({ subAccounts: [existingTokenAccount] });
-
-      const result = mergeSubAccounts(mockedAccount, [existingTokenAccount, newTokenAccount]);
-
-      expect(result.map(sa => sa.id)).toEqual(["ta1", "ta2"]);
-    });
-  });
+    it("avoids duplicated CONTRACT_CALL operation if confirmed erc20 operation exists", async () => {
+      const mockGetContractCallResult = jest.spyOn(apiClient, "getContractCallResult");
+      const mockFindTransactionByContractCall = jest.spyOn(
+        apiClient,
+        "findTransactionByContractCall",
+      );
 
-  describe("applyPendingExtras", () => {
-    test("merges valid extras from pending operations", () => {
-      const opExtra1: HederaOperationExtra = { consensusTimestamp: "1.2.3.4" };
-      const pendingExtra1: HederaOperationExtra = { associatedTokenId: "0.0.1234" };
+      const duplicateTxConsensusTimestamp = "1705836000.000000000";
+      const duplicateTxHash = "duplicate_tx";
+
+      const operationsWithDuplicate = [
+        getMockedOperation({
+          hash: duplicateTxHash,
+          type: "FEES",
+          standard: "erc20",
+          date: new Date("2024-01-20T10:00:00Z"),
+          blockHash: "0xBLOCK",
+          subOperations: [
+            getMockedOperation({
+              type: "OUT",
+              standard: "erc20",
+              hash: duplicateTxHash,
+              accountId: encodeTokenAccountId(ledgerAccountId, tokenCurrency),
+            }),
+          ],
+        }),
+        getMockedOperation({
+          hash: duplicateTxHash,
+          type: "CONTRACT_CALL",
+          date: new Date("2024-01-20T10:00:00Z"),
+        }),
+        getMockedOperation({
+          hash: "unique_tx",
+          type: "OUT",
+          date: new Date("2024-01-19T10:00:00Z"),
+        }),
+      ];
+
+      const duplicateERC20Transaction = getMockedThirdwebTransaction({
+        transactionHash: duplicateTxHash,
+        address: tokenCurrency.contractAddress,
+        blockHash: "0xBLOCK",
+        decoded: {
+          name: "Transfer",
+          signature: "Transfer(address,address,uint256)",
+          params: {
+            from: evmAddress,
+            to: "0xRECIPIENT",
+            value: "1000000",
+          },
+        },
+      });
 
-      const mockedOperation1 = getMockedOperation({ hash: "op1", extra: opExtra1 });
-      const mockedPendingOperation1 = getMockedOperation({ hash: "op1", extra: pendingExtra1 });
+      mockGetContractCallResult.mockResolvedValue({
+        timestamp: duplicateTxConsensusTimestamp,
+        contract_id: tokenCurrency.contractAddress,
+      } as any);
+
+      mockFindTransactionByContractCall.mockResolvedValue({
+        transaction_hash: duplicateTxHash,
+        consensus_timestamp: duplicateTxConsensusTimestamp,
+      } as any);
+
+      const { updatedOperations } = await integrateERC20Operations({
+        ledgerAccountId,
+        address,
+        allOperations: operationsWithDuplicate,
+        latestERC20Transactions: [duplicateERC20Transaction],
+        pendingOperationHashes: new Set(),
+        erc20OperationHashes: new Set([duplicateTxHash]),
+      });
 
-      const result = applyPendingExtras([mockedOperation1], [mockedPendingOperation1]);
+      const duplicatedContractCalls = updatedOperations.filter(
+        op => op.type === "CONTRACT_CALL" && op.hash === duplicateTxHash,
+      );
+      const feesOps = updatedOperations.filter(
+        op => op.type === "FEES" && op.hash === duplicateTxHash,
+      );
 
-      expect(result).toHaveLength(1);
-      expect(result[0].extra).toEqual({
-        ...mockedOperation1.extra,
-        ...mockedPendingOperation1.extra,
-      });
+      expect(updatedOperations).toHaveLength(2);
+      expect(duplicatedContractCalls).toHaveLength(0);
+      expect(feesOps).toHaveLength(1);
+      expect(feesOps).toMatchObject([{ blockHash: "0xBLOCK" }]);
     });
 
-    test("returns original operation if no matching pending is found", () => {
-      const opExtra: HederaOperationExtra = { consensusTimestamp: "1.2.3.4" };
-      const pendingExtra: HederaOperationExtra = { associatedTokenId: "0.0.1234" };
+    it("avoids duplicated CONTRACT_CALL operation if erc20 operation is pending", async () => {
+      const pendingTxHash = "pending_erc20";
+
+      const operationsWithPending = [
+        getMockedOperation({
+          hash: pendingTxHash,
+          type: "CONTRACT_CALL",
+          date: new Date("2024-01-20T10:00:00Z"),
+        }),
+        getMockedOperation({
+          hash: "confirmed_tx",
+          type: "OUT",
+          date: new Date("2024-01-19T10:00:00Z"),
+        }),
+      ];
+
+      const { updatedOperations } = await integrateERC20Operations({
+        ledgerAccountId,
+        address,
+        allOperations: operationsWithPending,
+        latestERC20Transactions: [],
+        pendingOperationHashes: new Set([pendingTxHash]),
+        erc20OperationHashes: new Set(),
+      });
 
-      const mockedOperation = getMockedOperation({ hash: "unknown", extra: opExtra });
-      const mockedPendingOperation = getMockedOperation({ hash: "op1", extra: pendingExtra });
+      const pendingOp = updatedOperations.find(op => op.hash === pendingTxHash);
 
-      const result = applyPendingExtras([mockedOperation], [mockedPendingOperation]);
-      expect(result).toHaveLength(1);
-      expect(result[0].extra).toEqual(mockedOperation.extra);
+      expect(pendingOp).toBeUndefined();
+      expect(updatedOperations).toHaveLength(1);
+      expect(updatedOperations[0].hash).toBe("confirmed_tx");
     });
-  });
 
-  describe("patchOperationWithExtra", () => {
-    test("adds extra to operation and nested sub operations", () => {
-      const mockedOperation = getMockedOperation({
-        hash: "parent",
-        extra: {},
-        subOperations: [getMockedOperation({ hash: "sub1", extra: {} })],
+    /**
+     * Timeline:
+     * - Tuesday: Normal transactions
+     * - Wednesday: ERC20 transfer (Mirror + Thirdweb in sync)
+     * - Thursday: Normal transaction
+     * - Friday: ERC20 transfer (Thirdweb stuck - no event)
+     * - Saturday: Normal transaction
+     *
+     * SYNC 1 (Friday):
+     * - Mirror Node shows CONTRACT_CALL without blockHash
+     * - Thirdweb has no event yet (indexer stuck)
+     * - Operation remains as CONTRACT_CALL (not enriched)
+     *
+     * SYNC 2 (Saturday):
+     * - Thirdweb catches up and returns Friday's event
+     * - CONTRACT_CALL should get patched to FEES with ERC20 sub-operation
+     */
+    it("handles delayed thirdweb indexer", async () => {
+      const mockGetContractCallResult = jest.spyOn(apiClient, "getContractCallResult");
+      const mockFindTransactionByContractCall = jest.spyOn(
+        apiClient,
+        "findTransactionByContractCall",
+      );
+
+      const fridayTxConsensusTimestamp = `1705678200.000000000`;
+
+      // sync 1 from Friday: thirdweb hasn't indexed yet
+      const fridaySyncOperations = [
+        getMockedOperation({
+          hash: "saturday_tx",
+          type: "OUT",
+          date: new Date("2024-01-20T10:00:00Z"),
+        }),
+        getMockedOperation({
+          hash: "friday_erc20",
+          type: "CONTRACT_CALL",
+          date: new Date("2024-01-19T15:30:00Z"),
+        }),
+        getMockedOperation({
+          hash: "thursday_tx",
+          type: "OUT",
+          date: new Date("2024-01-18T12:00:00Z"),
+        }),
+        getMockedOperation({
+          hash: "wednesday_erc20",
+          type: "FEES",
+          date: new Date("2024-01-17T09:00:00Z"),
+          standard: "erc20",
+          blockHash: "0xWEDNESDAY_BLOCK",
+          subOperations: [
+            getMockedOperation({
+              type: "OUT",
+              standard: "erc20",
+              hash: "wednesday_erc20",
+              accountId: encodeTokenAccountId(ledgerAccountId, tokenCurrency),
+            }),
+          ],
+        }),
+        getMockedOperation({
+          hash: "tuesday_tx",
+          type: "OUT",
+          date: new Date("2024-01-16T08:00:00Z"),
+        }),
+      ];
+
+      // thirdweb catches up with Friday's event
+      const lateERC20Transaction = getMockedThirdwebTransaction({
+        transactionHash: "friday_erc20",
+        address: tokenCurrency.contractAddress,
+        decoded: {
+          name: "Transfer",
+          signature: "Transfer(address,address,uint256)",
+          params: {
+            from: evmAddress,
+            to: "0xRECIPIENT",
+            value: "5000000",
+          },
+        },
       });
 
-      const extra: HederaOperationExtra = {
-        consensusTimestamp: "12345",
-        associatedTokenId: "0.0.1001",
-      };
+      mockGetContractCallResult.mockResolvedValue({
+        timestamp: fridayTxConsensusTimestamp,
+        contract_id: tokenCurrency.contractAddress,
+      } as any);
+
+      mockFindTransactionByContractCall.mockResolvedValue({
+        transaction_hash: lateERC20Transaction.transactionHash,
+        consensus_timestamp: fridayTxConsensusTimestamp,
+      } as any);
+
+      const { updatedOperations, newERC20TokenOperations } = await integrateERC20Operations({
+        ledgerAccountId,
+        address,
+        allOperations: fridaySyncOperations,
+        latestERC20Transactions: [lateERC20Transaction],
+        pendingOperationHashes: new Set(),
+        erc20OperationHashes: new Set(["wednesday_erc20"]),
+      });
 
-      const patched = patchOperationWithExtra(mockedOperation, extra);
+      // check if friday operation got patched
+      const wednesdayOp = updatedOperations.find(op => op.hash === "wednesday_erc20");
+      const fridayOp = updatedOperations.find(
+        op => op.hash === lateERC20Transaction.transactionHash,
+      );
 
-      expect(patched.extra).toEqual(extra);
-      expect(patched.subOperations).toHaveLength(1);
-      expect(patched.subOperations?.[0].extra).toEqual(extra);
+      expect(fridayOp).toMatchObject({
+        type: "FEES",
+        standard: "erc20",
+        hash: lateERC20Transaction.transactionHash,
+        subOperations: [
+          {
+            type: "OUT",
+            standard: "erc20",
+          },
+        ],
+      });
+      expect(newERC20TokenOperations).toHaveLength(1);
+      expect(newERC20TokenOperations).toMatchObject([
+        {
+          type: "OUT",
+          hash: lateERC20Transaction.transactionHash,
+          accountId: encodeTokenAccountId(ledgerAccountId, tokenCurrency),
+        },
+      ]);
+      expect(wednesdayOp).toMatchObject({
+        type: "FEES",
+        blockHash: "0xWEDNESDAY_BLOCK",
+      });
+      expect(updatedOperations[0]).toMatchObject({ hash: "saturday_tx" });
+      expect(updatedOperations.at(-1)).toMatchObject({ hash: "tuesday_tx" });
+      expect(updatedOperations).toHaveLength(fridaySyncOperations.length);
     });
   });
 });