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

package/src/bridge/utils.ts

@@ -1,5 +1,5 @@
 import BigNumber from "bignumber.js";
-import type { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
+import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import {
   decodeTokenAccountId,
   emptyHistoryCache,
@@ -7,15 +7,31 @@ import {
   findSubAccountById,
   isTokenAccount,
 } from "@ledgerhq/coin-framework/account";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import { HEDERA_OPERATION_TYPES } from "../constants";
 import { estimateMaxSpendable } from "./estimateMaxSpendable";
 import { estimateFees } from "../logic/estimateFees";
-import { isTokenAssociateTransaction, isValidExtra } from "../logic/utils";
-import type { HederaOperationExtra, Transaction, HederaMirrorToken } from "../types";
+import {
+  fromEVMAddress,
+  toEVMAddress,
+  getMemoFromBase64,
+  isTokenAssociateTransaction,
+  isValidExtra,
+  base64ToUrlSafeBase64,
+} from "../logic/utils";
+import { getERC20Operations, parseThirdwebTransactionParams } from "../network/utils";
+import type {
+  HederaOperationExtra,
+  Transaction,
+  OperationERC20,
+  HederaMirrorToken,
+  HederaERC20TokenBalance,
+  HederaThirdwebTransaction,
+  ERC20OperationFields,
+} from "../types";
 
 interface CalculateAmountResult {
   amount: BigNumber;
@@ -29,16 +45,16 @@ const calculateCoinAmount = async ({
 }: {
   account: Account;
   transaction: Transaction;
-  operationType: HEDERA_OPERATION_TYPES;
+  operationType: Exclude<HEDERA_OPERATION_TYPES, HEDERA_OPERATION_TYPES.ContractCall>;
 }): Promise<CalculateAmountResult> => {
-  const estimatedFees = await estimateFees(account.currency, operationType);
+  const estimatedFees = await estimateFees({ currency: account.currency, operationType });
   const amount = transaction.useAllAmount
     ? await estimateMaxSpendable({ account, transaction })
     : transaction.amount;
 
   return {
     amount,
-    totalSpent: amount.plus(estimatedFees),
+    totalSpent: amount.plus(estimatedFees.tinybars),
   };
 };
 
@@ -82,15 +98,24 @@ export const calculateAmount = ({
   return calculateCoinAmount({ account, transaction, operationType });
 };
 
-export const getSubAccounts = async (
-  accountId: string,
-  lastTokenOperations: Operation[],
-  mirrorTokens: HederaMirrorToken[],
-): Promise<TokenAccount[]> => {
+export const getSubAccounts = async ({
+  ledgerAccountId,
+  latestHTSTokenOperations,
+  latestERC20TokenOperations,
+  mirrorTokens,
+  erc20Tokens,
+}: {
+  ledgerAccountId: string;
+  latestHTSTokenOperations: Operation[];
+  latestERC20TokenOperations: Operation[];
+  mirrorTokens: HederaMirrorToken[];
+  erc20Tokens: HederaERC20TokenBalance[];
+}): Promise<TokenAccount[]> => {
   // Creating a Map of Operations by TokenCurrencies in order to know which TokenAccounts should be synced as well
   const operationsByToken = new Map<TokenCurrency, Operation[]>();
+  const subAccounts: TokenAccount[] = [];
 
-  for (const tokenOperation of lastTokenOperations) {
+  for (const tokenOperation of [...latestHTSTokenOperations, ...latestERC20TokenOperations]) {
     const { token } = await decodeTokenAccountId(tokenOperation.accountId);
     if (!token) continue;
 
@@ -107,13 +132,18 @@ export const getSubAccounts = async (
     operationsByToken.get(token)?.push(tokenOperation);
   }
 
-  const subAccounts: TokenAccount[] = [];
-
   // extract token accounts from existing operations
   for (const [token, tokenOperations] of operationsByToken.entries()) {
-    const parentAccountId = accountId;
-    const rawBalance = mirrorTokens.find(t => t.token_id === token.contractAddress)?.balance;
-    const balance = rawBalance !== undefined ? new BigNumber(rawBalance) : null;
+    const parentAccountId = ledgerAccountId;
+    let balance: BigNumber | null = null;
+
+    if (token.tokenType === "erc20") {
+      const rawBalance = erc20Tokens.find(t => t.token.contractAddress === token.contractAddress);
+      balance = rawBalance === undefined ? null : new BigNumber(rawBalance.balance);
+    } else {
+      const rawBalance = mirrorTokens.find(t => t.token_id === token.contractAddress)?.balance;
+      balance = rawBalance === undefined ? null : new BigNumber(rawBalance);
+    }
 
     if (!balance) {
       continue;
@@ -137,34 +167,41 @@ export const getSubAccounts = async (
   }
 
   // extract token accounts existing in the account's balance, but with no recorded operations yet
-  // e.g. tokens added via association flow, without any subsequent activity
-  for (const rawToken of mirrorTokens) {
-    const parentAccountId = accountId;
+  // e.g. hts tokens added via association flow, without any subsequent activity
+  // or erc20 tokens received from 3rd party
+  for (const rawToken of [...mirrorTokens, ...erc20Tokens]) {
+    const parentAccountId = ledgerAccountId;
     const rawBalance = rawToken.balance;
     const balance = new BigNumber(rawBalance);
-    const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(
-      rawToken.token_id,
-      "hedera",
-    );
+    const isERC20 = "token" in rawToken;
+    const tokenAddress = isERC20 ? rawToken.token.contractAddress : rawToken.token_id;
+    const token = await getCryptoAssetsStore().findTokenByAddressInCurrency(tokenAddress, "hedera");
 
     if (!token) {
       continue;
     }
 
     const id = encodeTokenAccountId(parentAccountId, token);
+    const operations = operationsByToken.get(token) ?? [];
 
     if (subAccounts.some(a => a.id === id)) {
       continue;
     }
 
+    if (isERC20 && operations.length === 0 && balance.isZero()) {
+      continue;
+    }
+
     subAccounts.push({
       type: "TokenAccount",
-      id: encodeTokenAccountId(parentAccountId, token),
+      id,
       parentId: parentAccountId,
       token,
       balance,
       spendableBalance: balance,
-      creationDate: new Date(parseFloat(rawToken.created_timestamp) * 1000),
+      creationDate: isERC20
+        ? new Date()
+        : new Date(Number.parseFloat(rawToken.created_timestamp) * 1000),
       operations: [],
       operationsCount: 0,
       pendingOperations: [],
@@ -350,3 +387,269 @@ export function patchOperationWithExtra(
     nftOperations: (operation.nftOperations ?? []).map(op => ({ ...op, extra })),
   };
 }
+
+// filter out CONTRACT_CALL operations based on pending and already existing ERC20 operations to avoid duplicates
+export const removeDuplicatedContractCallOperations = (
+  operations: Operation[],
+  pendingOperationHashes: Set<string>,
+  erc20OperationHashes: Set<string>,
+): Operation[] => {
+  return operations.filter(op => {
+    if (op.type !== "CONTRACT_CALL") {
+      return true;
+    }
+
+    const hashAlreadyExists =
+      erc20OperationHashes.has(op.hash) || pendingOperationHashes.has(op.hash);
+
+    return !hashAlreadyExists;
+  });
+};
+
+// loop over latestERC20Operations and prepare lists of transactions that should be patched and added
+// - patching happens when we have a matching CONTRACT_CALL operation without blockHash set (mirror node transaction without ERC20 details)
+// - adding happens when we have no matching operation
+export const classifyERC20Operations = ({
+  latestERC20Operations,
+  operationsByHash,
+  evmAccountAddress,
+}: {
+  latestERC20Operations: OperationERC20[];
+  operationsByHash: Map<string, Operation>;
+  evmAccountAddress: string | null;
+}): {
+  erc20OperationsToPatch: Map<string, OperationERC20>;
+  erc20OperationsToAdd: Map<string, OperationERC20>;
+} => {
+  const erc20OperationsToPatch = new Map<string, OperationERC20>();
+  const erc20OperationsToAdd = new Map<string, OperationERC20>();
+
+  for (const erc20Operation of latestERC20Operations) {
+    const hash = base64ToUrlSafeBase64(erc20Operation.mirrorTransaction.transaction_hash);
+    const existingOp = operationsByHash.get(hash);
+    const type =
+      erc20Operation.thirdwebTransaction.decoded.params.from === evmAccountAddress ? "OUT" : "IN";
+
+    if (!existingOp) {
+      erc20OperationsToAdd.set(hash, erc20Operation);
+      continue;
+    }
+
+    if (existingOp.type === "CONTRACT_CALL" && type === "OUT" && !existingOp.blockHash) {
+      erc20OperationsToPatch.set(hash, erc20Operation);
+      continue;
+    }
+  }
+
+  return { erc20OperationsToPatch, erc20OperationsToAdd };
+};
+
+// extracts common fields from an ERC20 operation
+const buildERC20OperationFields = ({
+  erc20Operation,
+  relatedExistingOperation,
+  variant,
+  evmAddress,
+}: {
+  variant: "patch" | "add";
+  evmAddress: string | null;
+  erc20Operation: OperationERC20;
+  relatedExistingOperation?: Operation;
+}): ERC20OperationFields | null => {
+  const decodedParams = parseThirdwebTransactionParams(erc20Operation.thirdwebTransaction);
+
+  if (!decodedParams) {
+    return null;
+  }
+
+  let type: OperationType = "OUT";
+  const standard = "erc20";
+  const blockHeight = 5;
+  const blockHash = erc20Operation.thirdwebTransaction.blockHash;
+  const consensusTimestamp = erc20Operation.mirrorTransaction.consensus_timestamp;
+  const timestamp = new Date(Number.parseInt(consensusTimestamp.split(".")[0], 10) * 1000);
+  const fee = BigNumber(erc20Operation.mirrorTransaction.charged_tx_fee);
+  const value = BigNumber(decodedParams.value);
+  const senderAddress = fromEVMAddress(decodedParams.from) ?? decodedParams.from;
+  const recipientAddress = fromEVMAddress(decodedParams.to) ?? decodedParams.to;
+  const memo = getMemoFromBase64(erc20Operation.mirrorTransaction.memo_base64);
+  const extra: HederaOperationExtra = {
+    ...(isValidExtra(relatedExistingOperation?.extra) && relatedExistingOperation.extra),
+    ...(memo && { memo }),
+    consensusTimestamp: erc20Operation.contractCallResult.timestamp,
+    transactionId: erc20Operation.mirrorTransaction.transaction_id,
+    gasConsumed: erc20Operation.contractCallResult.gas_consumed,
+    gasLimit: erc20Operation.contractCallResult.gas_limit,
+    gasUsed: erc20Operation.contractCallResult.gas_used,
+  };
+
+  if (variant === "add") {
+    type = decodedParams.from === evmAddress ? "OUT" : "IN";
+  }
+
+  return {
+    date: timestamp,
+    type,
+    fee,
+    value,
+    senders: [senderAddress],
+    recipients: [recipientAddress],
+    blockHeight,
+    blockHash,
+    extra,
+    standard,
+    hasFailed: false,
+  };
+};
+
+// patches an existing CONTRACT_CALL operation with ERC20 token operation details
+export const patchContractCallOperation = ({
+  relatedExistingOperation,
+  ledgerAccountId,
+  hash,
+  erc20Fields,
+  tokenOperation,
+}: {
+  relatedExistingOperation: Operation;
+  ledgerAccountId: string;
+  hash: string;
+  erc20Fields: ERC20OperationFields;
+  tokenOperation: Operation;
+}): void => {
+  Object.assign(relatedExistingOperation, {
+    ...erc20Fields,
+    id: encodeOperationId(ledgerAccountId, hash, "FEES"),
+    type: "FEES",
+    value: erc20Fields.fee,
+    subOperations: [tokenOperation],
+  });
+};
+
+export const integrateERC20Operations = async ({
+  ledgerAccountId,
+  address,
+  allOperations,
+  latestERC20Transactions,
+  pendingOperationHashes,
+  erc20OperationHashes,
+}: {
+  ledgerAccountId: string;
+  address: string;
+  allOperations: Operation[];
+  latestERC20Transactions: HederaThirdwebTransaction[];
+  pendingOperationHashes: Set<string>;
+  erc20OperationHashes: Set<string>;
+}): Promise<{
+  updatedOperations: Operation[];
+  newERC20TokenOperations: Operation[];
+}> => {
+  const newERC20TokenOperations: Operation[] = [];
+  const latestERC20Operations = await getERC20Operations(latestERC20Transactions);
+  const evmAddress = toEVMAddress(address);
+
+  // avoid duplicated CONTRACT_CALL operations if ERC20 operations are already present
+  const uniqueOperations = removeDuplicatedContractCallOperations(
+    allOperations,
+    pendingOperationHashes,
+    erc20OperationHashes,
+  );
+
+  // nothing to patch/add if no new ERC20 operations found
+  if (latestERC20Operations.length === 0) {
+    return {
+      updatedOperations: uniqueOperations,
+      newERC20TokenOperations,
+    };
+  }
+
+  // create copy to avoid mutating original array and index by hash for easy lookup
+  const updatedOperations = uniqueOperations.map(op => ({ ...op }));
+  const operationsByHash = updatedOperations.reduce((acc, curr) => {
+    acc.set(curr.hash, curr);
+    return acc;
+  }, new Map<string, Operation>());
+
+  // split erc20 operations into patch and add lists
+  const { erc20OperationsToPatch, erc20OperationsToAdd } = classifyERC20Operations({
+    latestERC20Operations,
+    operationsByHash,
+    evmAccountAddress: evmAddress,
+  });
+
+  // patch existing operations with data from thirdweb
+  for (const [hash, erc20Operation] of erc20OperationsToPatch.entries()) {
+    const relatedExistingOperation = operationsByHash.get(hash);
+    if (!relatedExistingOperation) continue;
+
+    const erc20Fields = buildERC20OperationFields({
+      variant: "patch",
+      evmAddress,
+      erc20Operation,
+      relatedExistingOperation,
+    });
+    if (!erc20Fields) continue;
+
+    const encodedTokenAccountId = encodeTokenAccountId(ledgerAccountId, erc20Operation.token);
+    const encodedOperationId = encodeOperationId(encodedTokenAccountId, hash, erc20Fields.type);
+    const tokenOperation: Operation<HederaOperationExtra> = {
+      ...erc20Fields,
+      id: encodedOperationId,
+      accountId: encodedTokenAccountId,
+      hash,
+    };
+
+    patchContractCallOperation({
+      relatedExistingOperation,
+      ledgerAccountId,
+      hash,
+      erc20Fields,
+      tokenOperation,
+    });
+
+    newERC20TokenOperations.push(tokenOperation);
+  }
+
+  // create new operations for remaining ERC20 operations
+  for (const [hash, erc20Operation] of erc20OperationsToAdd.entries()) {
+    const erc20Fields = buildERC20OperationFields({
+      variant: "add",
+      evmAddress,
+      erc20Operation,
+    });
+    if (!erc20Fields) continue;
+
+    const encodedTokenAccountId = encodeTokenAccountId(ledgerAccountId, erc20Operation.token);
+    const encodedOperationId = encodeOperationId(encodedTokenAccountId, hash, erc20Fields.type);
+    const tokenOperation: Operation<HederaOperationExtra> = {
+      ...erc20Fields,
+      id: encodedOperationId,
+      accountId: encodedTokenAccountId,
+      hash,
+    };
+
+    const coinOperation: Operation<HederaOperationExtra> =
+      erc20Fields.type === "OUT"
+        ? {
+            ...erc20Fields,
+            id: encodeOperationId(ledgerAccountId, hash, "FEES"),
+            accountId: ledgerAccountId,
+            type: "FEES",
+            value: erc20Fields.fee,
+            hash,
+          }
+        : await makeCoinOperationForOrphanChildOperation(tokenOperation);
+
+    coinOperation.subOperations = [tokenOperation];
+    updatedOperations.push(coinOperation);
+    newERC20TokenOperations.push(tokenOperation);
+  }
+
+  // ensure operations lists are sorted correctly
+  updatedOperations.sort((a, b) => b.date.getTime() - a.date.getTime());
+  newERC20TokenOperations.sort((a, b) => b.date.getTime() - a.date.getTime());
+
+  return {
+    updatedOperations,
+    newERC20TokenOperations,
+  };
+};

package/src/constants.ts

@@ -1,3 +1,5 @@
+import BigNumber from "bignumber.js";
+
 /**
  * Internal types to distinguish custom Hedera transaction behaviors.
  * These can be used in transaction.mode and used to route specific preparation logic.
@@ -14,17 +16,29 @@ export enum HEDERA_OPERATION_TYPES {
   CryptoTransfer = "CryptoTransfer",
   TokenTransfer = "TokenTransfer",
   TokenAssociate = "TokenAssociate",
+  ContractCall = "ContractCall",
 }
 
 export const TINYBAR_SCALE = 8;
 
-export const ESTIMATED_FEE_SAFETY_RATE = 2;
-
 // old value moved from https://github.com/LedgerHQ/ledger-live/blob/8447b68b7c6f1e7ccd4aa9db4da0e6c8de36a88e/libs/coin-modules/coin-hedera/src/bridge/utils.ts#L77
 export const DEFAULT_TINYBAR_FEE = 150200;
 
 export const SYNTHETIC_BLOCK_WINDOW_SECONDS = 10;
 
+export const ERC20_TRANSFER_EVENT_TOPIC =
+  "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+
+export const ESTIMATED_GAS_SAFETY_RATE = 1.2;
+
+export const ESTIMATED_FEE_SAFETY_RATE = 2;
+
+export const DEFAULT_GAS_LIMIT = new BigNumber(100_000);
+
+export const DEFAULT_GAS_PRICE_TINYBARS = new BigNumber(100);
+
+export const HEDERA_MAINNET_CHAIN_ID = 295;
+
 /**
  * https://docs.hedera.com/hedera/networks/mainnet/fees
  *
@@ -38,4 +52,35 @@ export const BASE_USD_FEE_BY_OPERATION_TYPE = {
   [HEDERA_OPERATION_TYPES.CryptoTransfer]: 0.0001 * 10 ** TINYBAR_SCALE,
   [HEDERA_OPERATION_TYPES.TokenTransfer]: 0.001 * 10 ** TINYBAR_SCALE,
   [HEDERA_OPERATION_TYPES.TokenAssociate]: 0.05 * 10 ** TINYBAR_SCALE,
+  [HEDERA_OPERATION_TYPES.ContractCall]: 0, // Contract call fees are based on gas used and are handled separately
 } as const satisfies Record<HEDERA_OPERATION_TYPES, number>;
+
+/**
+ * Array of supported ERC20 token IDs for Hedera.
+ *
+ * This is a temporary solution to allow bypassing deprecated methods.
+ * It is essential to update this list in the future to ensure support
+ * for other erc20 tokens.
+ */
+export const SUPPORTED_ERC20_TOKENS = [
+  {
+    id: "hedera/erc20/weth_0xca367694cdac8f152e33683bb36cc9d6a73f1ef2",
+    contractAddress: "0xca367694cdac8f152e33683bb36cc9d6a73f1ef2",
+    tokenId: "0.0.9470869",
+  },
+  {
+    id: "hedera/erc20/bonzo_atoken_usdc_0xb7687538c7f4cad022d5e97cc778d0b46457c5db",
+    contractAddress: "0xb7687538c7f4cad022d5e97cc778d0b46457c5db",
+    tokenId: "0.0.7308496",
+  },
+  {
+    id: "hedera/erc20/audd_0x39ceba2b467fa987546000eb5d1373acf1f3a2e1",
+    contractAddress: "0x39ceba2b467fa987546000eb5d1373acf1f3a2e1",
+    tokenId: "0.0.8317070",
+  },
+  {
+    id: "hedera/erc20/wrapped_btc_0xd7d4d91d64a6061fa00a94e2b3a2d2a5fb677849",
+    contractAddress: "0xd7d4d91d64a6061fa00a94e2b3a2d2a5fb677849",
+    tokenId: "0.0.10047837",
+  },
+];

package/src/deviceTransactionConfig.ts

@@ -1,5 +1,6 @@
-import type { AccountLike, Account } from "@ledgerhq/types-live";
 import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import { HEDERA_TRANSACTION_MODES } from "./constants";
 import { isTokenAssociateTransaction } from "./logic/utils";
 import type { Transaction, TransactionStatus } from "./types";
 
@@ -40,6 +41,14 @@ async function getDeviceTransactionConfig({
     });
   }
 
+  if (transaction.mode === HEDERA_TRANSACTION_MODES.Send && transaction.gasLimit) {
+    fields.push({
+      type: "text",
+      label: "Gas Limit",
+      value: transaction.gasLimit.toString(),
+    });
+  }
+
   if (transaction.memo) {
     fields.push({
       type: "text",

package/src/errors.ts

@@ -13,3 +13,6 @@ export const HederaRecipientTokenAssociationRequired = createCustomErrorClass(
 export const HederaRecipientTokenAssociationUnverified = createCustomErrorClass(
   "HederaRecipientTokenAssociationUnverified",
 );
+export const HederaRecipientEvmAddressVerificationRequired = createCustomErrorClass(
+  "HederaRecipientEvmAddressVerificationRequired",
+);

package/src/logic/craftTransaction.test.ts

@@ -3,7 +3,7 @@ import * as sdk from "@hashgraph/sdk";
 import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/index";
 import { HEDERA_TRANSACTION_MODES, TINYBAR_SCALE } from "../constants";
 import { craftTransaction } from "./craftTransaction";
-import type { HederaMemo } from "../types";
+import type { HederaMemo, HederaTxData } from "../types";
 import { serializeTransaction } from "./utils";
 
 jest.mock("./utils");
@@ -39,8 +39,8 @@ describe("craftTransaction", () => {
     const senderTransfer = result.tx.hbarTransfers?.get(txIntent.sender);
     const recipientTransfer = result.tx.hbarTransfers?.get(txIntent.recipient);
 
-    expect(senderTransfer).toEqual(sdk.Hbar.fromTinybars(-txIntent.amount));
-    expect(recipientTransfer).toEqual(sdk.Hbar.fromTinybars(txIntent.amount));
+    expect(senderTransfer).toEqual(sdk.Hbar.fromTinybars((-txIntent.amount).toString()));
+    expect(recipientTransfer).toEqual(sdk.Hbar.fromTinybars(txIntent.amount.toString()));
     expect(result.tx.transactionMemo).toBe(txIntent.memo.value);
     expect(serializeTransaction).toHaveBeenCalled();
     expect(result).toEqual({
@@ -49,7 +49,7 @@ describe("craftTransaction", () => {
     });
   });
 
-  it("should craft a token transfer transaction", async () => {
+  it("should craft HTS token transfer transaction", async () => {
     const txIntent = {
       intentType: "transaction",
       type: HEDERA_TRANSACTION_MODES.Send,
@@ -76,10 +76,50 @@ describe("craftTransaction", () => {
     const senderTransfer = tokenTransfers?.get(txIntent.sender);
     const recipientTransfer = tokenTransfers?.get(txIntent.recipient);
 
-    // .toString() is used because tokenTransfers values are Long objects
-    // this is internal dependency of @hashgraph/sdk, re-exported in newer version
-    expect(senderTransfer?.toString()).toEqual((-txIntent.amount).toString());
-    expect(recipientTransfer?.toString()).toEqual(txIntent.amount.toString());
+    expect(senderTransfer).toEqual(sdk.Long.fromBigInt(-txIntent.amount));
+    expect(recipientTransfer).toEqual(sdk.Long.fromBigInt(txIntent.amount));
+    expect(result.tx.transactionMemo).toBe("Token transfer");
+    expect(serializeTransaction).toHaveBeenCalled();
+    expect(result).toEqual({
+      tx: expect.any(Object),
+      serializedTx: "serialized-transaction",
+    });
+  });
+
+  it("should craft ERC20 token transfer transaction", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.Send,
+      amount: BigInt(1000),
+      recipient: "0.0.12345",
+      sender: "0.0.54321",
+      asset: {
+        type: "erc20",
+        assetReference: "0x39ceba2b467fa987546000eb5d1373acf1f3a2e1",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Token transfer",
+      },
+      data: {
+        type: "erc20",
+        gasLimit: BigInt(100000),
+      },
+    } satisfies TransactionIntent<HederaMemo, HederaTxData>;
+
+    const result = await craftTransaction(txIntent);
+
+    expect(result.tx).toBeInstanceOf(sdk.ContractExecuteTransaction);
+    invariant(
+      result.tx instanceof sdk.ContractExecuteTransaction,
+      "ContractExecuteTransaction type guard",
+    );
+
+    expect(result.tx.gas).toEqual(sdk.Long.fromBigInt(txIntent.data.gasLimit));
+    expect(result.tx.contractId).toEqual(
+      sdk.ContractId.fromEvmAddress(0, 0, txIntent.asset.assetReference),
+    );
     expect(result.tx.transactionMemo).toBe("Token transfer");
     expect(serializeTransaction).toHaveBeenCalled();
     expect(result).toEqual({
@@ -150,7 +190,7 @@ describe("craftTransaction", () => {
 
     expect(result.tx).toBeInstanceOf(sdk.TransferTransaction);
     invariant(result.tx instanceof sdk.TransferTransaction, "TransferTransaction type guard");
-    expect(result.tx.maxTransactionFee).toEqual(sdk.Hbar.fromTinybars(customFees.value));
+    expect(result.tx.maxTransactionFee).toEqual(sdk.Hbar.fromTinybars(customFees.value.toString()));
   });
 
   it("should throw error when token associate transaction has invalid asset type", async () => {