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

package/src/logic/craftTransaction.ts

@@ -2,14 +2,17 @@ import BigNumber from "bignumber.js";
 import invariant from "invariant";
 import {
   AccountId,
+  ContractExecuteTransaction,
+  ContractFunctionParameters,
+  ContractId,
   Hbar,
   TokenAssociateTransaction,
   TransactionId,
   TransferTransaction,
 } from "@hashgraph/sdk";
 import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/index";
-import { HEDERA_TRANSACTION_MODES } from "../constants";
-import type { HederaMemo } from "../types";
+import { DEFAULT_GAS_LIMIT, HEDERA_TRANSACTION_MODES } from "../constants";
+import type { HederaMemo, HederaTxData } from "../types";
 import { serializeTransaction } from "./utils";
 
 // avoid "sign" prompt loop by having only one node (one transaction)
@@ -32,13 +35,21 @@ interface BuilderCoinTransferTransaction extends BuilderCommonTransactionFields
   recipient: string;
 }
 
-interface BuilderTokenTransferTransaction extends BuilderCommonTransactionFields {
+interface BuilderHTSTokenTransferTransaction extends BuilderCommonTransactionFields {
   type: HEDERA_TRANSACTION_MODES.Send;
-  tokenId: string;
+  tokenAddress: string;
   amount: BigNumber;
   recipient: string;
 }
 
+interface BuilderERC20TokenTransferTransaction extends BuilderCommonTransactionFields {
+  type: HEDERA_TRANSACTION_MODES.Send;
+  tokenAddress: string;
+  amount: BigNumber;
+  recipient: string;
+  gasLimit: BigNumber;
+}
+
 interface BuilderTokenAssociateTransaction extends BuilderCommonTransactionFields {
   type: HEDERA_TRANSACTION_MODES.TokenAssociate;
   tokenId: string;
@@ -68,15 +79,15 @@ async function buildUnsignedCoinTransaction({
   return tx.freeze();
 }
 
-async function buildUnsignedTokenTransaction({
+async function buildUnsignedHTSTokenTransaction({
   account,
   transaction,
 }: {
   account: BuilderOperator;
-  transaction: BuilderTokenTransferTransaction;
+  transaction: BuilderHTSTokenTransferTransaction;
 }): Promise<TransferTransaction> {
   const accountId = account.accountId;
-  const tokenId = transaction.tokenId;
+  const tokenId = transaction.tokenAddress;
 
   const tx = new TransferTransaction()
     .setNodeAccountIds(nodeAccountIds)
@@ -92,6 +103,39 @@ async function buildUnsignedTokenTransaction({
   return tx.freeze();
 }
 
+async function buildUnsignedERC20TokenTransaction({
+  account,
+  transaction,
+}: {
+  account: BuilderOperator;
+  transaction: BuilderERC20TokenTransferTransaction;
+}): Promise<ContractExecuteTransaction> {
+  const accountId = AccountId.fromString(account.accountId);
+  const contractId = ContractId.fromEvmAddress(0, 0, transaction.tokenAddress);
+  const recipientEvmAddress = AccountId.fromString(transaction.recipient).toSolidityAddress();
+  const gas = transaction.gasLimit.toNumber();
+
+  // create function parameters for ERC20 transfer function
+  // transfer(address to, uint256 amount) returns (bool)
+  const functionParameters = new ContractFunctionParameters()
+    .addAddress(recipientEvmAddress)
+    .addUint256(transaction.amount.toNumber());
+
+  const tx = new ContractExecuteTransaction()
+    .setNodeAccountIds(nodeAccountIds)
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo ?? "")
+    .setContractId(contractId)
+    .setGas(gas)
+    .setFunction("transfer", functionParameters);
+
+  if (transaction.maxFee) {
+    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
+  }
+
+  return tx.freeze();
+}
+
 async function buildTokenAssociateTransaction({
   account,
   transaction,
@@ -116,7 +160,7 @@ async function buildTokenAssociateTransaction({
 }
 
 export async function craftTransaction(
-  txIntent: TransactionIntent<HederaMemo>,
+  txIntent: TransactionIntent<HederaMemo, HederaTxData>,
   customFees?: FeeEstimation,
 ) {
   const account = {
@@ -138,20 +182,41 @@ export async function craftTransaction(
         maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
       },
     });
-  } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type !== "native") {
+  } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "hts") {
     invariant("assetReference" in txIntent.asset, "hedera: no assetReference in token transfer");
 
     const amount = new BigNumber(txIntent.amount.toString());
 
-    tx = await buildUnsignedTokenTransaction({
+    tx = await buildUnsignedHTSTokenTransaction({
       account,
       transaction: {
         type: txIntent.type,
-        tokenId: txIntent.asset.assetReference,
+        tokenAddress: txIntent.asset.assetReference,
+        amount,
+        recipient: txIntent.recipient,
+        memo: txIntent.memo.value,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+      },
+    });
+  } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "erc20") {
+    invariant("assetReference" in txIntent.asset, "hedera: no assetReference in token transfer");
+
+    const amount = new BigNumber(txIntent.amount.toString());
+    const gasLimit =
+      "data" in txIntent && txIntent.data.gasLimit
+        ? new BigNumber(txIntent.data.gasLimit.toString())
+        : DEFAULT_GAS_LIMIT;
+
+    tx = await buildUnsignedERC20TokenTransaction({
+      account,
+      transaction: {
+        type: txIntent.type,
+        tokenAddress: txIntent.asset.assetReference,
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
         maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+        gasLimit,
       },
     });
   } else {

package/src/logic/estimateFees.test.ts

@@ -1,19 +1,29 @@
 import BigNumber from "bignumber.js";
 import cvsApi from "@ledgerhq/live-countervalues/api/index";
 import {
+  DEFAULT_GAS_LIMIT,
+  DEFAULT_GAS_PRICE_TINYBARS,
   DEFAULT_TINYBAR_FEE,
   ESTIMATED_FEE_SAFETY_RATE,
+  ESTIMATED_GAS_SAFETY_RATE,
   HEDERA_OPERATION_TYPES,
+  HEDERA_TRANSACTION_MODES,
   TINYBAR_SCALE,
 } from "../constants";
 import { estimateFees } from "./estimateFees";
 import { getMockedAccount } from "../test/fixtures/account.fixture";
-import { getCurrencyToUSDRate } from "./utils";
+import { getCurrencyToUSDRate, toEVMAddress } from "./utils";
+import { apiClient } from "../network/api";
+import { getMockedERC20TokenCurrency } from "../test/fixtures/currency.fixture";
 
 jest.mock("@ledgerhq/live-countervalues/api/index");
+jest.mock("../network/api");
 
 describe("getEstimatedFees", () => {
   const mockedAccount = getMockedAccount();
+  const mockedTokenCurrencyERC20 = getMockedERC20TokenCurrency();
+  const senderAddress = "0.0.12345";
+  const recipientAddress = "0.0.67890";
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -21,79 +31,218 @@ describe("getEstimatedFees", () => {
     getCurrencyToUSDRate.clear(mockedAccount.currency.ticker);
   });
 
-  test("returns estimated fee based on USD rate for CryptoTransfer", async () => {
+  it("returns estimated fee based on USD rate for CryptoTransfer", async () => {
     const usdRate = 1; // 1 HBAR = 1 USD
     (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
 
-    const result = await estimateFees(
-      mockedAccount.currency,
-      HEDERA_OPERATION_TYPES.CryptoTransfer,
-    );
+    const result = await estimateFees({
+      currency: mockedAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+    });
 
     const baseFeeTinybar = 0.0001 * 10 ** TINYBAR_SCALE;
-    const expectedFee = new BigNumber(baseFeeTinybar)
+    const expectedTinybars = new BigNumber(baseFeeTinybar)
       .div(usdRate)
       .integerValue(BigNumber.ROUND_CEIL)
       .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
 
-    expect(result).toEqual(expectedFee);
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+    });
   });
 
-  test("returns estimated fee based on USD rate for TokenTransfer", async () => {
+  it("returns estimated fee based on USD rate for TokenTransfer", async () => {
     const usdRate = 0.5; // 1 HBAR = 0.5 USD
     (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
 
-    const result = await estimateFees(mockedAccount.currency, HEDERA_OPERATION_TYPES.TokenTransfer);
+    const result = await estimateFees({
+      currency: mockedAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.TokenTransfer,
+    });
 
     const baseFeeTinybar = 0.001 * 10 ** TINYBAR_SCALE;
-    const expectedFee = new BigNumber(baseFeeTinybar)
+    const expectedTinybars = new BigNumber(baseFeeTinybar)
       .div(usdRate)
       .integerValue(BigNumber.ROUND_CEIL)
       .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
 
-    expect(result).toEqual(expectedFee);
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+    });
   });
 
-  test("returns estimated fee based on USD rate for TokenAssociate", async () => {
+  it("returns estimated fee based on USD rate for TokenAssociate", async () => {
     const usdRate = 2; // 1 HBAR = 2 USD
     (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
 
-    const result = await estimateFees(
-      mockedAccount.currency,
-      HEDERA_OPERATION_TYPES.TokenAssociate,
-    );
+    const result = await estimateFees({
+      currency: mockedAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.TokenAssociate,
+    });
 
     const baseFeeTinybar = 0.05 * 10 ** TINYBAR_SCALE;
-    const expectedFee = new BigNumber(baseFeeTinybar)
+    const expectedTinybars = new BigNumber(baseFeeTinybar)
       .div(usdRate)
       .integerValue(BigNumber.ROUND_CEIL)
       .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
 
-    expect(result).toEqual(expectedFee);
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+    });
+  });
+
+  it("returns estimated fee based on gas for ContractCall", async () => {
+    const estimatedGasLimit = new BigNumber(50000);
+    const gasPriceTinybars = new BigNumber(900);
+    const transferAmount = BigInt(1000000);
+
+    (apiClient.getNetworkFees as jest.Mock).mockResolvedValueOnce({
+      fees: [
+        {
+          transaction_type: "ContractCall",
+          gas: gasPriceTinybars.toNumber(),
+        },
+      ],
+    });
+
+    (apiClient.estimateContractCallGas as jest.Mock).mockResolvedValueOnce(estimatedGasLimit);
+
+    const result = await estimateFees({
+      operationType: HEDERA_OPERATION_TYPES.ContractCall,
+      txIntent: {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        sender: senderAddress,
+        recipient: recipientAddress,
+        amount: transferAmount,
+        asset: {
+          type: "erc20",
+          assetReference: mockedTokenCurrencyERC20.contractAddress,
+        },
+      },
+    });
+
+    const expectedGas = estimatedGasLimit
+      .multipliedBy(ESTIMATED_GAS_SAFETY_RATE)
+      .integerValue(BigNumber.ROUND_CEIL);
+
+    const expectedTinybars = expectedGas
+      .multipliedBy(gasPriceTinybars)
+      .integerValue(BigNumber.ROUND_CEIL);
+
+    expect(apiClient.getNetworkFees).toHaveBeenCalledTimes(1);
+    expect(apiClient.estimateContractCallGas).toHaveBeenCalledTimes(1);
+    expect(apiClient.estimateContractCallGas).toHaveBeenCalledWith(
+      toEVMAddress(senderAddress),
+      toEVMAddress(recipientAddress),
+      mockedTokenCurrencyERC20.contractAddress,
+      transferAmount,
+    );
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+      gas: expectedGas,
+    });
+  });
+
+  it("falls back to default gas values when getNetworkFees fail", async () => {
+    const transferAmount = BigInt(1000000);
+
+    (apiClient.getNetworkFees as jest.Mock).mockRejectedValueOnce(new Error("Network error"));
+
+    const result = await estimateFees({
+      operationType: HEDERA_OPERATION_TYPES.ContractCall,
+      txIntent: {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        sender: senderAddress,
+        recipient: recipientAddress,
+        amount: transferAmount,
+        asset: {
+          type: "erc20",
+          assetReference: mockedTokenCurrencyERC20.contractAddress,
+        },
+      },
+    });
+
+    const expectedGas = DEFAULT_GAS_LIMIT;
+    const expectedTinybars = new BigNumber(expectedGas)
+      .multipliedBy(DEFAULT_GAS_PRICE_TINYBARS)
+      .integerValue(BigNumber.ROUND_CEIL);
+
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+      gas: expectedGas,
+    });
   });
 
-  test("falls back to default estimate when cvs api returns null", async () => {
+  it("falls back to default gas values when estimateContractCallGas fail", async () => {
+    const transferAmount = BigInt(1000000);
+
+    (apiClient.getNetworkFees as jest.Mock).mockResolvedValueOnce({
+      fees: [],
+    });
+    (apiClient.estimateContractCallGas as jest.Mock).mockRejectedValueOnce(
+      new Error("Network error"),
+    );
+
+    const result = await estimateFees({
+      operationType: HEDERA_OPERATION_TYPES.ContractCall,
+      txIntent: {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        sender: senderAddress,
+        recipient: recipientAddress,
+        amount: transferAmount,
+        asset: {
+          type: "erc20",
+          assetReference: mockedTokenCurrencyERC20.contractAddress,
+        },
+      },
+    });
+
+    const expectedGas = DEFAULT_GAS_LIMIT;
+    const expectedTinybars = new BigNumber(expectedGas)
+      .multipliedBy(DEFAULT_GAS_PRICE_TINYBARS)
+      .integerValue(BigNumber.ROUND_CEIL);
+
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+      gas: expectedGas,
+    });
+  });
+
+  it("falls back to default estimate when cvs api returns null", async () => {
     const usdRate = null;
     (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
 
-    const result = await estimateFees(
-      mockedAccount.currency,
-      HEDERA_OPERATION_TYPES.CryptoTransfer,
+    const result = await estimateFees({
+      currency: mockedAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+    });
+
+    const expectedTinybars = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(
+      ESTIMATED_FEE_SAFETY_RATE,
     );
 
-    const expected = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
-    expect(result).toEqual(expected);
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+    });
   });
 
-  test("falls back to default estimate on cvs api failure", async () => {
+  it("falls back to default estimate on cvs api failure", async () => {
     (cvsApi.fetchLatest as jest.Mock).mockRejectedValueOnce(new Error("Network error"));
 
-    const result = await estimateFees(
-      mockedAccount.currency,
-      HEDERA_OPERATION_TYPES.CryptoTransfer,
+    const result = await estimateFees({
+      currency: mockedAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+    });
+
+    const expectedTinybars = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(
+      ESTIMATED_FEE_SAFETY_RATE,
     );
 
-    const expected = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
-    expect(result).toEqual(expected);
+    expect(result).toMatchObject({
+      tinybars: expectedTinybars,
+    });
   });
 });

package/src/logic/estimateFees.ts

@@ -1,28 +1,89 @@
 import BigNumber from "bignumber.js";
+import type { TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import {
   BASE_USD_FEE_BY_OPERATION_TYPE,
+  DEFAULT_GAS_LIMIT,
+  DEFAULT_GAS_PRICE_TINYBARS,
   DEFAULT_TINYBAR_FEE,
   ESTIMATED_FEE_SAFETY_RATE,
+  ESTIMATED_GAS_SAFETY_RATE,
   HEDERA_OPERATION_TYPES,
 } from "../constants";
-import { getCurrencyToUSDRate } from "./utils";
+import { apiClient } from "../network/api";
+import type { EstimateFeesParams, EstimateFeesResult } from "../types";
+import { getCurrencyToUSDRate, toEVMAddress } from "./utils";
 
-export const estimateFees = async (
+const estimateContractCallFees = async (
+  txIntent: TransactionIntent,
+): Promise<EstimateFeesResult> => {
+  let tinybars = new BigNumber(0);
+  let gas = new BigNumber(0);
+
+  const tokenEvmAddress = "assetReference" in txIntent.asset ? txIntent.asset.assetReference : null;
+  const senderEvmAddress = toEVMAddress(txIntent.sender);
+  const recipientEvmAddress = toEVMAddress(txIntent.recipient);
+
+  if (!tokenEvmAddress || !senderEvmAddress || !recipientEvmAddress) {
+    return {
+      tinybars,
+    };
+  }
+
+  try {
+    const [networkFees, gasLimit] = await Promise.all([
+      apiClient.getNetworkFees(),
+      apiClient.estimateContractCallGas(
+        senderEvmAddress,
+        recipientEvmAddress,
+        tokenEvmAddress,
+        txIntent.amount,
+      ),
+    ]);
+
+    const contractCallFees = networkFees.fees.find(
+      fee => fee.transaction_type === HEDERA_OPERATION_TYPES.ContractCall,
+    );
+    const gasTinybarRate = new BigNumber(contractCallFees?.gas ?? DEFAULT_GAS_PRICE_TINYBARS);
+    gas = gasLimit.multipliedBy(ESTIMATED_GAS_SAFETY_RATE).integerValue(BigNumber.ROUND_CEIL);
+    tinybars = gas.multipliedBy(gasTinybarRate).integerValue(BigNumber.ROUND_CEIL);
+  } catch {
+    const gasTinybarRate = DEFAULT_GAS_PRICE_TINYBARS;
+    gas = DEFAULT_GAS_LIMIT;
+    tinybars = gas.multipliedBy(gasTinybarRate).integerValue(BigNumber.ROUND_CEIL);
+  }
+
+  return {
+    tinybars,
+    gas,
+  };
+};
+
+const estimateStandardFees = async (
   currency: CryptoCurrency,
   operationType: HEDERA_OPERATION_TYPES,
-): Promise<BigNumber> => {
-  let fee: BigNumber | undefined;
+): Promise<EstimateFeesResult> => {
+  let tinybars: BigNumber;
   const usdRate = await getCurrencyToUSDRate(currency).catch(() => null);
 
   if (usdRate) {
-    fee = new BigNumber(BASE_USD_FEE_BY_OPERATION_TYPE[operationType])
+    tinybars = new BigNumber(BASE_USD_FEE_BY_OPERATION_TYPE[operationType])
       .dividedBy(new BigNumber(usdRate))
       .integerValue(BigNumber.ROUND_CEIL)
       .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
   } else {
-    fee = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+    tinybars = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+  }
+
+  return {
+    tinybars,
+  };
+};
+
+export const estimateFees = async (params: EstimateFeesParams): Promise<EstimateFeesResult> => {
+  if (params.operationType === HEDERA_OPERATION_TYPES.ContractCall) {
+    return estimateContractCallFees(params.txIntent);
   }
 
-  return fee;
+  return estimateStandardFees(params.currency, params.operationType);
 };

package/src/logic/getAssetFromToken.test.ts

@@ -1,10 +1,10 @@
 import { getAssetFromToken } from "./getAssetFromToken";
-import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+import { getMockedHTSTokenCurrency } from "../test/fixtures/currency.fixture";
 
 describe("getAssetFromToken", () => {
   it("returns asset from TEST token", () => {
     const owner = "owner";
-    const token = getMockedTokenCurrency({
+    const token = getMockedHTSTokenCurrency({
       contractAddress: "0.0.1234567",
       name: "TEST",
       units: [

package/src/logic/getBalance.test.ts

@@ -1,13 +1,11 @@
-import { getBalance } from "./getBalance";
-import { apiClient } from "../network/api";
-import { getMockedCurrency } from "../test/fixtures/currency.fixture";
 import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getBalance } from "./getBalance";
+import { apiClient } from "../network/api";
+import { getMockedCurrency, getMockedHTSTokenCurrency } from "../test/fixtures/currency.fixture";
 
 jest.mock("../network/api");
 
-setupMockCryptoAssetsStore();
-
 describe("getBalance", () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -53,42 +51,16 @@ describe("getBalance", () => {
         token_id: "0.0.7890",
         balance: "5000",
       },
-      {
-        token_id: "0.0.9876",
-        balance: "10000",
-      },
     ];
-    const mockToken1: TokenCurrency = {
-      type: "TokenCurrency",
-      id: "token1",
+    const mockTokenHTS = getMockedHTSTokenCurrency({
       contractAddress: "0.0.7890",
-      tokenType: "hts",
-      name: "Test Token 1",
-      ticker: "TT1",
-      parentCurrency: mockCurrency,
-      units: [{ name: "TT1", code: "tt1", magnitude: 6 }],
-      delisted: false,
-      disableCountervalue: false,
-    };
-    const mockToken2: TokenCurrency = {
-      type: "TokenCurrency",
-      id: "token2",
-      contractAddress: "0.0.9876",
-      tokenType: "hts",
-      name: "Test Token 2",
-      ticker: "TT2",
-      parentCurrency: mockCurrency,
-      units: [{ name: "TT2", code: "tt2", magnitude: 8 }],
-      delisted: false,
-      disableCountervalue: false,
-    };
+    });
 
     const findTokenByAddressInCurrencyMock = jest
       .fn()
       .mockImplementation(
         async (tokenId: string, _currencyId: string): Promise<TokenCurrency | undefined> => {
-          if (tokenId === "0.0.7890") return mockToken1;
-          if (tokenId === "0.0.9876") return mockToken2;
+          if (tokenId === "0.0.7890") return mockTokenHTS;
           return undefined;
         },
       );
@@ -106,10 +78,9 @@ describe("getBalance", () => {
     expect(apiClient.getAccount).toHaveBeenCalledWith(address);
     expect(apiClient.getAccountTokens).toHaveBeenCalledTimes(1);
     expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
-    expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledTimes(2);
+    expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledTimes(1);
     expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledWith("0.0.7890", "hedera");
-    expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledWith("0.0.9876", "hedera");
-    expect(result).toHaveLength(3);
+    expect(result).toHaveLength(2);
     expect(result).toEqual(
       expect.arrayContaining([
         {
@@ -119,21 +90,11 @@ describe("getBalance", () => {
         {
           value: BigInt("5000"),
           asset: {
-            type: mockToken1.tokenType,
-            assetReference: mockToken1.contractAddress,
-            assetOwner: address,
-            name: mockToken1.name,
-            unit: mockToken1.units[0],
-          },
-        },
-        {
-          value: BigInt("10000"),
-          asset: {
-            type: mockToken2.tokenType,
-            assetReference: mockToken2.contractAddress,
+            type: mockTokenHTS.tokenType,
+            assetReference: mockTokenHTS.contractAddress,
             assetOwner: address,
-            name: mockToken2.name,
-            unit: mockToken2.units[0],
+            name: mockTokenHTS.name,
+            unit: mockTokenHTS.units[0],
           },
         },
       ]),
@@ -158,7 +119,7 @@ describe("getBalance", () => {
         balance: "10000",
       },
     ];
-    const mockToken1: TokenCurrency = {
+    const mockTokenHTS: TokenCurrency = {
       type: "TokenCurrency",
       id: "token1",
       contractAddress: "0.0.7890",
@@ -175,7 +136,7 @@ describe("getBalance", () => {
       .fn()
       .mockImplementation(
         async (tokenId: string, _currencyId: string): Promise<TokenCurrency | undefined> => {
-          if (tokenId === "0.0.7890") return mockToken1;
+          if (tokenId === "0.0.7890") return mockTokenHTS;
           return undefined;
         },
       );
@@ -197,11 +158,11 @@ describe("getBalance", () => {
     expect(result[1]).toEqual({
       value: BigInt("5000"),
       asset: {
-        type: mockToken1.tokenType,
-        assetReference: mockToken1.contractAddress,
+        type: mockTokenHTS.tokenType,
+        assetReference: mockTokenHTS.contractAddress,
         assetOwner: address,
-        name: mockToken1.name,
-        unit: mockToken1.units[0],
+        name: mockTokenHTS.name,
+        unit: mockTokenHTS.units[0],
       },
     });
   });