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

package/src/bridge/getTransactionStatus.test.ts

@@ -7,20 +7,26 @@ import {
 } from "@ledgerhq/errors";
 import { HEDERA_TRANSACTION_MODES } from "../constants";
 import {
-  HederaRecipientInvalidChecksum,
   HederaInsufficientFundsForAssociation,
+  HederaRecipientEvmAddressVerificationRequired,
+  HederaRecipientInvalidChecksum,
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
 } from "../errors";
 import { getTransactionStatus } from "./getTransactionStatus";
 import * as estimateFees from "../logic/estimateFees";
 import * as logicUtils from "../logic/utils";
+import { rpcClient } from "../network/rpc";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
-import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+import {
+  getMockedERC20TokenCurrency,
+  getMockedHTSTokenCurrency,
+} from "../test/fixtures/currency.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
+import type { EstimateFeesResult } from "../types";
 
 describe("getTransactionStatus", () => {
-  const mockedEstimatedFee = new BigNumber(1);
+  const mockedEstimatedFee: EstimateFeesResult = { tinybars: new BigNumber(1) };
   const mockedUsdRate = new BigNumber(1);
   const validRecipientAddress = "0.0.1234567";
   const validRecipientAddressWithChecksum = "0.0.1234567-ylkls";
@@ -32,6 +38,10 @@ describe("getTransactionStatus", () => {
     jest.spyOn(estimateFees, "estimateFees").mockResolvedValueOnce(mockedEstimatedFee);
   });
 
+  afterAll(() => {
+    rpcClient._resetInstance();
+  });
+
   test("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(1000) });
     const mockedTransaction = getMockedTransaction({
@@ -47,10 +57,10 @@ describe("getTransactionStatus", () => {
     expect(result.totalSpent.isGreaterThan(100)).toBe(true);
   });
 
-  test("token transfer with valid recipient and sufficient balance completes successfully", async () => {
+  test("hts token transfer with valid recipient and sufficient balance completes successfully", async () => {
     jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(true);
 
-    const tokenCurrency = getMockedTokenCurrency();
+    const tokenCurrency = getMockedHTSTokenCurrency();
     const tokenAccount = getMockedTokenAccount(tokenCurrency, { balance: new BigNumber(500) });
     const account = getMockedAccount({ balance: new BigNumber(1000), subAccounts: [tokenAccount] });
     const transaction = getMockedTransaction({
@@ -66,8 +76,27 @@ describe("getTransactionStatus", () => {
     expect(result.amount).toEqual(new BigNumber(200));
   });
 
+  test("erc20 token transfer with valid recipient and sufficient balance completes successfully", async () => {
+    const tokenCurrency = getMockedERC20TokenCurrency();
+    const tokenAccount = getMockedTokenAccount(tokenCurrency, { balance: new BigNumber(500) });
+    const account = getMockedAccount({ balance: new BigNumber(1000), subAccounts: [tokenAccount] });
+    const transaction = getMockedTransaction({
+      subAccountId: tokenAccount.id,
+      recipient: validRecipientAddress,
+      amount: new BigNumber(200),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toMatchObject({
+      unverifiedEvmAddress: expect.any(Error),
+    });
+    expect(result.amount).toEqual(new BigNumber(200));
+  });
+
   test("token associate transaction with sufficient USD worth completes successfully", async () => {
-    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
       mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
@@ -81,8 +110,8 @@ describe("getTransactionStatus", () => {
     expect(result.amount).toEqual(new BigNumber(0));
     expect(result.errors).toEqual({});
     expect(result.warnings).toEqual({});
-    expect(result.totalSpent).toEqual(mockedEstimatedFee);
-    expect(result.estimatedFees).toEqual(mockedEstimatedFee);
+    expect(result.totalSpent).toEqual(mockedEstimatedFee.tinybars);
+    expect(result.estimatedFees).toEqual(mockedEstimatedFee.tinybars);
   });
 
   test("recipient with checksum is supported", async () => {
@@ -137,7 +166,7 @@ describe("getTransactionStatus", () => {
   });
 
   test("adds error if USD balance is too low for token association", async () => {
-    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
     const mockedTransaction = getMockedTransaction({
       mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
@@ -156,7 +185,7 @@ describe("getTransactionStatus", () => {
   test("adds warning during token transfer if recipient has no token associated", async () => {
     jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(false);
 
-    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
     const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
     const mockedTransaction = getMockedTransaction({
@@ -171,12 +200,28 @@ describe("getTransactionStatus", () => {
     );
   });
 
+  test("adds evm address verification warning during ERC20 token transfer", async () => {
+    const mockedTokenCurrency = getMockedERC20TokenCurrency();
+    const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
+    const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
+    const mockedTransaction = getMockedTransaction({
+      subAccountId: mockedTokenAccount.id,
+      recipient: validRecipientAddress,
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.warnings.unverifiedEvmAddress).toBeInstanceOf(
+      HederaRecipientEvmAddressVerificationRequired,
+    );
+  });
+
   test("adds warning if token association status can't be verified", async () => {
     jest
       .spyOn(logicUtils, "checkAccountTokenAssociationStatus")
       .mockRejectedValueOnce(new HederaRecipientTokenAssociationUnverified());
 
-    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
     const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
     const mockedTransaction = getMockedTransaction({
@@ -192,7 +237,7 @@ describe("getTransactionStatus", () => {
   });
 
   test("adds error during token transfer with insufficient balance", async () => {
-    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency, {
       balance: new BigNumber(0),
     });

package/src/bridge/getTransactionStatus.ts

@@ -6,13 +6,14 @@ import {
   RecipientRequired,
 } from "@ledgerhq/errors";
 import type { Account, AccountBridge, TokenAccount } from "@ledgerhq/types-live";
-import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account";
 import { getEnv } from "@ledgerhq/live-env";
-import { HEDERA_OPERATION_TYPES } from "../constants";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
 import {
   HederaInsufficientFundsForAssociation,
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
+  HederaRecipientEvmAddressVerificationRequired,
 } from "../errors";
 import { estimateFees } from "../logic/estimateFees";
 import {
@@ -57,11 +58,14 @@ async function handleTokenAssociateTransaction(
 
   const [usdRate, estimatedFees] = await Promise.all([
     getCurrencyToUSDRate(account.currency),
-    estimateFees(account.currency, HEDERA_OPERATION_TYPES.TokenAssociate),
+    estimateFees({
+      currency: account.currency,
+      operationType: HEDERA_OPERATION_TYPES.TokenAssociate,
+    }),
   ]);
 
   const amount = BigNumber(0);
-  const totalSpent = amount.plus(estimatedFees);
+  const totalSpent = amount.plus(estimatedFees.tinybars);
   const isAssociationFlow = isTokenAssociationRequired(account, transaction.properties.token);
 
   if (isAssociationFlow) {
@@ -79,22 +83,26 @@ async function handleTokenAssociateTransaction(
   return {
     amount,
     totalSpent,
-    estimatedFees,
+    estimatedFees: estimatedFees.tinybars,
     errors,
     warnings,
   };
 }
 
-async function handleTokenTransaction(
+async function handleHTSTokenTransaction(
   account: Account,
   subAccount: TokenAccount,
   transaction: Transaction,
 ): Promise<TransactionStatus> {
   const errors: Errors = {};
   const warnings: Warnings = {};
+
   const [calculatedAmount, estimatedFees] = await Promise.all([
     calculateAmount({ transaction, account }),
-    estimateFees(account.currency, HEDERA_OPERATION_TYPES.TokenTransfer),
+    estimateFees({
+      currency: account.currency,
+      operationType: HEDERA_OPERATION_TYPES.TokenTransfer,
+    }),
   ]);
 
   const recipientError = validateRecipient(account, transaction.recipient);
@@ -107,7 +115,7 @@ async function handleTokenTransaction(
     try {
       const hasRecipientTokenAssociated = await checkAccountTokenAssociationStatus(
         transaction.recipient,
-        subAccount.token.contractAddress,
+        subAccount.token,
       );
 
       if (!hasRecipientTokenAssociated) {
@@ -126,14 +134,70 @@ async function handleTokenTransaction(
     errors.amount = new NotEnoughBalance();
   }
 
-  if (account.balance.isLessThan(estimatedFees)) {
+  if (account.balance.isLessThan(estimatedFees.tinybars)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  return {
+    amount: calculatedAmount.amount,
+    totalSpent: calculatedAmount.totalSpent,
+    estimatedFees: estimatedFees.tinybars,
+    errors,
+    warnings,
+  };
+}
+
+async function handleERC20TokenTransaction(
+  account: Account,
+  subAccount: TokenAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> {
+  const errors: Errors = {};
+  const warnings: Warnings = {
+    unverifiedEvmAddress: new HederaRecipientEvmAddressVerificationRequired(),
+  };
+
+  const [calculatedAmount, estimatedFees] = await Promise.all([
+    calculateAmount({ transaction, account }),
+    estimateFees({
+      operationType: HEDERA_OPERATION_TYPES.ContractCall,
+      txIntent: {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        asset: {
+          type: "erc20",
+          assetReference: subAccount.token.contractAddress,
+          assetOwner: account.freshAddress,
+        },
+        amount: BigInt(transaction.amount.toString()),
+        sender: account.freshAddress,
+        recipient: transaction.recipient,
+      },
+    }),
+  ]);
+
+  const recipientError = validateRecipient(account, transaction.recipient);
+
+  if (recipientError) {
+    errors.recipient = recipientError;
+  }
+
+  if (transaction.amount.eq(0)) {
+    errors.amount = new AmountRequired();
+  }
+
+  if (subAccount.balance.isLessThan(calculatedAmount.totalSpent)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (account.balance.isLessThan(estimatedFees.tinybars)) {
     errors.amount = new NotEnoughBalance();
   }
 
   return {
     amount: calculatedAmount.amount,
     totalSpent: calculatedAmount.totalSpent,
-    estimatedFees,
+    estimatedFees: estimatedFees.tinybars,
     errors,
     warnings,
   };
@@ -145,9 +209,13 @@ async function handleCoinTransaction(
 ): Promise<TransactionStatus> {
   const errors: Errors = {};
   const warnings: Warnings = {};
+
   const [calculatedAmount, estimatedFees] = await Promise.all([
     calculateAmount({ transaction, account }),
-    estimateFees(account.currency, HEDERA_OPERATION_TYPES.CryptoTransfer),
+    estimateFees({
+      currency: account.currency,
+      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+    }),
   ]);
 
   const recipientError = validateRecipient(account, transaction.recipient);
@@ -167,7 +235,7 @@ async function handleCoinTransaction(
   return {
     amount: calculatedAmount.amount,
     totalSpent: calculatedAmount.totalSpent,
-    estimatedFees,
+    estimatedFees: estimatedFees.tinybars,
     errors,
     warnings,
   };
@@ -179,12 +247,17 @@ export const getTransactionStatus: AccountBridge<
   TransactionStatus
 >["getTransactionStatus"] = async (account, transaction) => {
   const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
-  const isTokenTransaction = isTokenAccount(subAccount);
+  const isHTSTokenTransaction =
+    transaction.mode === HEDERA_TRANSACTION_MODES.Send && subAccount?.token.tokenType === "hts";
+  const isERC20TokenTransaction =
+    transaction.mode === HEDERA_TRANSACTION_MODES.Send && subAccount?.token.tokenType === "erc20";
 
   if (isTokenAssociateTransaction(transaction)) {
     return handleTokenAssociateTransaction(account, transaction);
-  } else if (isTokenTransaction) {
-    return handleTokenTransaction(account, subAccount, transaction);
+  } else if (isHTSTokenTransaction) {
+    return handleHTSTokenTransaction(account, subAccount, transaction);
+  } else if (isERC20TokenTransaction) {
+    return handleERC20TokenTransaction(account, subAccount, transaction);
   } else {
     return handleCoinTransaction(account, transaction);
   }

package/src/bridge/index.ts

@@ -14,7 +14,7 @@ import { getTransactionStatus } from "./getTransactionStatus";
 import { prepareTransaction } from "./prepareTransaction";
 import { receive } from "./receive";
 import { buildSignOperation } from "./signOperation";
-import { getAccountShape, buildIterateResult } from "./synchronisation";
+import { getAccountShape, buildIterateResult, postSync } from "./synchronisation";
 import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
 import resolver from "../signer/index";
 import type { Transaction, TransactionStatus, HederaSigner, HederaAccount } from "../types";
@@ -35,7 +35,7 @@ function buildCurrencyBridge(signerContext: SignerContext<HederaSigner>): Curren
   };
 }
 
-const sync = makeSync({ getAccountShape });
+const sync = makeSync({ getAccountShape, postSync, shouldMergeOps: false });
 
 function buildAccountBridge(
   signerContext: SignerContext<HederaSigner>,

package/src/bridge/js-estimateMaxSpendable.integration.test.ts

@@ -3,21 +3,22 @@ import { createBridges } from ".";
 import { HEDERA_OPERATION_TYPES } from "../constants";
 import { estimateFees } from "../logic/estimateFees";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
-import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+import { getMockedHTSTokenCurrency } from "../test/fixtures/currency.fixture";
+import type { EstimateFeesResult } from "../types";
 
 describe("js-estimateMaxSpendable", () => {
   let bridge: ReturnType<typeof createBridges>;
-  let estimatedFees: Record<"crypto", BigNumber>;
+  let estimatedFees: Record<"crypto", EstimateFeesResult>;
 
   beforeAll(async () => {
     const signer = jest.fn();
     bridge = createBridges(signer);
 
     const mockedAccount = getMockedAccount();
-    const crypto = await estimateFees(
-      mockedAccount.currency,
-      HEDERA_OPERATION_TYPES.CryptoTransfer,
-    );
+    const crypto = await estimateFees({
+      currency: mockedAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+    });
 
     estimatedFees = { crypto };
   });
@@ -29,11 +30,13 @@ describe("js-estimateMaxSpendable", () => {
       account: mockedAccount,
     });
 
-    expect(result).toEqual(mockedAccount.balance.minus(estimatedFees.crypto));
+    const expected = mockedAccount.balance.minus(estimatedFees.crypto.tinybars);
+
+    expect(result).toEqual(expected);
   });
 
   test("estimateMaxSpendable returns 0 if balance < estimated fees", async () => {
-    const mockedAccount = getMockedAccount({ balance: estimatedFees.crypto.minus(1) });
+    const mockedAccount = getMockedAccount({ balance: estimatedFees.crypto.tinybars.minus(1) });
 
     const result = await bridge.accountBridge.estimateMaxSpendable({
       account: mockedAccount,
@@ -43,7 +46,7 @@ describe("js-estimateMaxSpendable", () => {
   });
 
   test("estimateMaxSpendable returns token balance for token account", async () => {
-    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
     const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
 

package/src/bridge/prepareTransaction.test.ts

@@ -4,17 +4,19 @@ import { prepareTransaction } from "./prepareTransaction";
 import { getMockedAccount } from "../test/fixtures/account.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
 import * as utils from "./utils";
+import type { EstimateFeesResult } from "../types";
 
 jest.mock("../logic/estimateFees");
 
 describe("prepareTransaction", () => {
   const mockAccount = getMockedAccount();
   const mockTx = getMockedTransaction();
+  const mockFeeEstimation: EstimateFeesResult = { tinybars: new BigNumber(10) };
 
   beforeEach(() => {
     jest.clearAllMocks();
 
-    (estimateFees as jest.Mock).mockResolvedValue(Promise.resolve(new BigNumber(10)));
+    (estimateFees as jest.Mock).mockResolvedValue(mockFeeEstimation);
     jest
       .spyOn(utils, "calculateAmount")
       .mockResolvedValue(

package/src/bridge/prepareTransaction.ts

@@ -1,9 +1,9 @@
-import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 import type { AccountBridge } from "@ledgerhq/types-live";
-import { HEDERA_OPERATION_TYPES } from "../constants";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
 import { estimateFees } from "../logic/estimateFees";
 import { isTokenAssociateTransaction } from "../logic/utils";
-import type { Transaction } from "../types";
+import type { EstimateFeesParams, Transaction } from "../types";
 import { calculateAmount } from "./utils";
 
 /**
@@ -18,31 +18,66 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
   account,
   transaction,
 ): Promise<Transaction> => {
-  const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
-  const isTokenTransaction = isTokenAccount(subAccount);
+  let estimateFeesParams: EstimateFeesParams;
   let operationType: HEDERA_OPERATION_TYPES;
+  const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
+  const isHTSTokenTransaction =
+    transaction.mode === HEDERA_TRANSACTION_MODES.Send && subAccount?.token.tokenType === "hts";
+  const isERC20TokenTransaction =
+    transaction.mode === HEDERA_TRANSACTION_MODES.Send && subAccount?.token.tokenType === "erc20";
 
   if (isTokenAssociateTransaction(transaction)) {
     operationType = HEDERA_OPERATION_TYPES.TokenAssociate;
-  } else if (isTokenTransaction) {
+  } else if (isHTSTokenTransaction) {
     operationType = HEDERA_OPERATION_TYPES.TokenTransfer;
+  } else if (isERC20TokenTransaction) {
+    operationType = HEDERA_OPERATION_TYPES.ContractCall;
   } else {
     operationType = HEDERA_OPERATION_TYPES.CryptoTransfer;
   }
 
+  // build different estimation params for ERC20 ContractCall transactions
+  if (operationType === HEDERA_OPERATION_TYPES.ContractCall) {
+    estimateFeesParams = {
+      operationType,
+      txIntent: {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        asset: {
+          type: "erc20",
+          assetReference: subAccount?.token.contractAddress ?? "",
+          assetOwner: account.freshAddress,
+        },
+        amount: BigInt(transaction.amount.toString()),
+        sender: account.freshAddress,
+        recipient: transaction.recipient,
+      },
+    };
+  } else {
+    estimateFeesParams = {
+      currency: account.currency,
+      operationType,
+    };
+  }
+
   // explicitly calculate transaction amount to account for `useAllAmount` flag (send max flow)
   // i.e. if `useAllAmount` has been toggled to true, this is where it will update the transaction to reflect that action
-  const [{ amount }, estimatedFees] = await Promise.all([
+  const [calculatedAmount, estimatedFees] = await Promise.all([
     calculateAmount({ account, transaction }),
-    estimateFees(account.currency, operationType),
+    estimateFees(estimateFeesParams),
   ]);
 
+  transaction.amount = calculatedAmount.amount;
+
   // `maxFee` must be explicitly set to avoid the @hashgraph/sdk default fallback
   // this ensures device app validation passes (e.g. during swap flow)
   // it's applied via `tx.setMaxTransactionFee` when building the transaction
-  transaction.maxFee = estimatedFees;
+  transaction.maxFee = estimatedFees.tinybars;
 
-  transaction.amount = amount;
+  // ERC20 transactions should have gas limit set (tinybars fee is calculated based on gas)
+  if (isERC20TokenTransaction && estimatedFees.gas) {
+    transaction.gasLimit = estimatedFees.gas;
+  }
 
   return transaction;
 };

package/src/bridge/signOperation.ts

@@ -2,9 +2,9 @@ import { Observable } from "rxjs";
 import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 import { buildOptimisticOperation } from "./buildOptimisticOperation";
-import { HEDERA_TRANSACTION_MODES } from "../constants";
+import { DEFAULT_GAS_LIMIT, HEDERA_TRANSACTION_MODES } from "../constants";
 import { combine } from "../logic/combine";
 import { craftTransaction } from "../logic/craftTransaction";
 import {
@@ -13,7 +13,7 @@ import {
   getHederaTransactionBodyBytes,
   isTokenAssociateTransaction,
 } from "../logic/utils";
-import type { Transaction, HederaSigner } from "../types";
+import type { Transaction, HederaSigner, HederaTxData } from "../types";
 
 export const buildSignOperation =
   (
@@ -29,10 +29,16 @@ export const buildSignOperation =
 
           let type: Transaction["mode"];
           let asset: AssetInfo;
+          let data: HederaTxData | undefined;
           const accountAddress = account.freshAddress;
           const accountPublicKey = account.seedIdentifier;
           const subAccount = findSubAccountById(account, transaction.subAccountId || "");
-          const isTokenTransaction = isTokenAccount(subAccount);
+          const isHTSTokenTransaction =
+            transaction.mode === HEDERA_TRANSACTION_MODES.Send &&
+            subAccount?.token.tokenType === "hts";
+          const isERC20TokenTransaction =
+            transaction.mode === HEDERA_TRANSACTION_MODES.Send &&
+            subAccount?.token.tokenType === "erc20";
 
           if (isTokenAssociateTransaction(transaction)) {
             type = HEDERA_TRANSACTION_MODES.TokenAssociate;
@@ -40,13 +46,24 @@ export const buildSignOperation =
               type: transaction.properties.token.tokenType,
               assetReference: transaction.properties.token.contractAddress,
             };
-          } else if (isTokenTransaction) {
+          } else if (isHTSTokenTransaction) {
             type = HEDERA_TRANSACTION_MODES.Send;
             asset = {
               type: subAccount.token.tokenType,
               assetReference: subAccount.token.contractAddress,
               assetOwner: accountAddress,
             };
+          } else if (isERC20TokenTransaction) {
+            type = HEDERA_TRANSACTION_MODES.Send;
+            asset = {
+              type: subAccount.token.tokenType,
+              assetReference: subAccount.token.contractAddress,
+              assetOwner: accountAddress,
+            };
+            data = {
+              type: "erc20",
+              gasLimit: BigInt((transaction.gasLimit ?? DEFAULT_GAS_LIMIT).toString()),
+            };
           } else {
             type = HEDERA_TRANSACTION_MODES.Send;
             asset = {
@@ -72,6 +89,7 @@ export const buildSignOperation =
                   type: "string",
                   value: transaction.memo ?? "",
                 },
+                ...(data && { data }),
               },
               customFees,
             );

package/src/bridge/synchronisation.test.ts

@@ -0,0 +1,67 @@
+import type { Account } from "@ledgerhq/types-live";
+import { postSync } from "./synchronisation";
+import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
+import { getMockedOperation } from "../test/fixtures/operation.fixture";
+import { getMockedHTSTokenCurrency } from "../test/fixtures/currency.fixture";
+
+describe("postSync", () => {
+  it("should remove pending operations that match confirmed ERC20 operations", () => {
+    const confirmedERC20Ops = [
+      getMockedOperation({ hash: "hash1", standard: "erc20" }),
+      getMockedOperation({ hash: "hash2", standard: "erc20" }),
+    ];
+
+    const initialAccount = {} as Account;
+    const syncedAccount = getMockedAccount({
+      operations: [...confirmedERC20Ops, getMockedOperation({ hash: "otherHash" })],
+      pendingOperations: [
+        getMockedOperation({ hash: "hash1" }),
+        getMockedOperation({ hash: "hash2" }),
+        getMockedOperation({ hash: "hash3" }),
+      ],
+    });
+
+    const result = postSync(initialAccount, syncedAccount);
+
+    expect(result.pendingOperations).toHaveLength(1);
+    expect(result.pendingOperations).toMatchObject([{ hash: "hash3" }]);
+  });
+
+  it("should filter pending operations from subaccounts", () => {
+    const mockToken1 = getMockedHTSTokenCurrency();
+
+    const confirmedERC20Ops = [
+      getMockedOperation({ hash: "hash1", standard: "erc20" }),
+      getMockedOperation({ hash: "hash2", standard: "erc20" }),
+    ];
+
+    const subAccounts = [
+      getMockedTokenAccount(mockToken1, {
+        pendingOperations: [
+          getMockedOperation({ hash: "hash1" }),
+          getMockedOperation({ hash: "hash4" }),
+        ],
+      }),
+      getMockedTokenAccount(mockToken1, {
+        pendingOperations: [
+          getMockedOperation({ hash: "hash2" }),
+          getMockedOperation({ hash: "hash5" }),
+        ],
+      }),
+    ];
+
+    const initialAccount = {} as Account;
+    const syncedAccount = getMockedAccount({
+      operations: [...confirmedERC20Ops, getMockedOperation({ hash: "otherHash" })],
+      subAccounts,
+    });
+
+    const result = postSync(initialAccount, syncedAccount);
+
+    expect(result.subAccounts).toHaveLength(2);
+    expect(result.subAccounts).toMatchObject([
+      { pendingOperations: [{ hash: "hash4" }] },
+      { pendingOperations: [{ hash: "hash5" }] },
+    ]);
+  });
+});