@ledgerhq/coin-hedera 1.16.0-nightly.20251218023953 → 1.16.0-nightly.20251220023811

package/src/logic/estimateFees.test.ts

@@ -96,6 +96,11 @@ describe("getEstimatedFees", () => {
     const gasPriceTinybars = new BigNumber(900);
     const transferAmount = BigInt(1000000);
 
+    (apiClient.getAccount as jest.Mock).mockImplementation(address => ({
+      address,
+      evm_address: "0x0000000000000000000000000000000000012345",
+    }));
+
     (apiClient.getNetworkFees as jest.Mock).mockResolvedValueOnce({
       fees: [
         {
@@ -130,11 +135,12 @@ describe("getEstimatedFees", () => {
       .multipliedBy(gasPriceTinybars)
       .integerValue(BigNumber.ROUND_CEIL);
 
+    expect(apiClient.getAccount).toHaveBeenCalledTimes(2);
     expect(apiClient.getNetworkFees).toHaveBeenCalledTimes(1);
     expect(apiClient.estimateContractCallGas).toHaveBeenCalledTimes(1);
     expect(apiClient.estimateContractCallGas).toHaveBeenCalledWith(
-      toEVMAddress(senderAddress),
-      toEVMAddress(recipientAddress),
+      await toEVMAddress(senderAddress),
+      await toEVMAddress(recipientAddress),
       mockedTokenCurrencyERC20.contractAddress,
       transferAmount,
     );

package/src/logic/estimateFees.ts

@@ -21,8 +21,10 @@ const estimateContractCallFees = async (
   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);
+  const [senderEvmAddress, recipientEvmAddress] = await Promise.all([
+    toEVMAddress(txIntent.sender),
+    toEVMAddress(txIntent.recipient),
+  ]);
 
   if (!tokenEvmAddress || !senderEvmAddress || !recipientEvmAddress) {
     return {

package/src/logic/getBlock.test.ts

@@ -47,10 +47,10 @@ describe("getBlock", () => {
     expect(getTimestampRangeFromBlockHeight).toHaveBeenCalledWith(42);
     expect(getBlockInfo).toHaveBeenCalledWith(42);
     expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledTimes(1);
-    expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledWith(
-      mockTimestampRange.start,
-      mockTimestampRange.end,
-    );
+    expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledWith({
+      startTimestamp: `gte:${mockTimestampRange.start}`,
+      endTimestamp: `lt:${mockTimestampRange.end}`,
+    });
   });
 
   it("should extract fee payer from transaction_id", async () => {

package/src/logic/getBlock.ts

@@ -66,7 +66,10 @@ function createStakingRewardOperations(tx: HederaMirrorTransaction): BlockOperat
 export async function getBlock(height: number): Promise<Block> {
   const { start, end } = getTimestampRangeFromBlockHeight(height);
   const blockInfo = await getBlockInfo(height);
-  const transactions = await apiClient.getTransactionsByTimestampRange(start, end);
+  const transactions = await apiClient.getTransactionsByTimestampRange({
+    startTimestamp: `gte:${start}`,
+    endTimestamp: `lt:${end}`,
+  });
 
   // analyze CRYPTOUPDATEACCOUNT transactions to distinguish staking operations from regular account updates.
   // this creates a map of transaction_hash -> StakingAnalysis to avoid repeated lookups.

package/src/logic/utils.test.ts

@@ -9,6 +9,7 @@ import {
   HEDERA_OPERATION_TYPES,
   HEDERA_TRANSACTION_MODES,
   SYNTHETIC_BLOCK_WINDOW_SECONDS,
+  OP_TYPES_EXCLUDING_FEES,
 } from "../constants";
 import { HederaRecipientInvalidChecksum } from "../errors";
 import { apiClient } from "../network/api";
@@ -64,6 +65,7 @@ import {
   getOperationDetailsExtraFields,
   calculateAPY,
   analyzeStakingOperation,
+  calculateUncommittedBalanceChange,
 } from "./utils";
 
 jest.mock("../network/api");
@@ -152,14 +154,16 @@ describe("logic utils", () => {
       expect(getOperationValue({ asset: tokenAsset, operation })).toBe(BigInt(0));
     });
 
-    it("should substract fee from value for native OUT operations", () => {
-      const operation = getMockedOperation({
-        type: "OUT",
-        value: BigNumber(1000),
-        fee: BigNumber(100),
-      });
+    it("should subtract fee from native operations that exclude fees", () => {
+      OP_TYPES_EXCLUDING_FEES.forEach(type => {
+        const operation = getMockedOperation({
+          type,
+          value: BigNumber(1000),
+          fee: BigNumber(100),
+        });
 
-      expect(getOperationValue({ asset: nativeAsset, operation })).toBe(BigInt(900));
+        expect(getOperationValue({ asset: nativeAsset, operation })).toBe(BigInt(900));
+      });
     });
 
     it("should return value for other operations", () => {
@@ -606,13 +610,27 @@ describe("logic utils", () => {
   });
 
   describe("toEVMAddress", () => {
-    it("returns correct EVM address for valid Hedera account ID", () => {
-      const evmAddress = toEVMAddress("0.0.12345");
-      expect(evmAddress).toBe("0x0000000000000000000000000000000000003039");
+    const mockMirrorAccount = {
+      account: "0.0.12345",
+      evm_address: "0x0000000000000000000000000000000000003039",
+    };
+
+    it("returns correct EVM address for valid Hedera account ID", async () => {
+      (apiClient.getAccount as jest.Mock).mockResolvedValueOnce(mockMirrorAccount);
+
+      const evmAddress = await toEVMAddress(mockMirrorAccount.account);
+
+      expect(apiClient.getAccount).toHaveBeenCalledTimes(1);
+      expect(apiClient.getAccount).toHaveBeenCalledWith(mockMirrorAccount.account);
+      expect(evmAddress).toBe(mockMirrorAccount.evm_address);
     });
 
-    it("returns null for invalid Hedera account ID", () => {
-      const evmAddress = toEVMAddress("invalid_account_id");
+    it("returns null when API call fails", async () => {
+      (apiClient.getAccount as jest.Mock).mockRejectedValueOnce(new Error("API error"));
+
+      const evmAddress = await toEVMAddress(mockMirrorAccount.account);
+
+      expect(apiClient.getAccount).toHaveBeenCalledTimes(1);
       expect(evmAddress).toBeNull();
     });
   });
@@ -970,6 +988,123 @@ describe("logic utils", () => {
     });
   });
 
+  describe("calculateUncommittedBalanceChange", () => {
+    const mockAddress = "0.0.12345";
+    const mockStartTimestamp = "1762202064.065172388";
+    const mockEndTimestamp = "1762202074.065172388";
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it("should return 0 when there are no transactions in the time range", async () => {
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce([]);
+
+      const result = await calculateUncommittedBalanceChange({
+        address: mockAddress,
+        startTimestamp: mockStartTimestamp,
+        endTimestamp: mockEndTimestamp,
+      });
+
+      expect(result).toEqual(new BigNumber(0));
+      expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledTimes(1);
+      expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledWith({
+        address: mockAddress,
+        startTimestamp: `gt:${mockStartTimestamp}`,
+        endTimestamp: `lte:${mockEndTimestamp}`,
+      });
+    });
+
+    it("should calculate balance change with mixed incoming and outgoing transfers", async () => {
+      const mockTransactions = [
+        {
+          consensus_timestamp: "1762202065.000000000",
+          transfers: [
+            { account: mockAddress, amount: 2000 },
+            { account: "0.0.98", amount: -2000 },
+          ],
+        },
+        {
+          consensus_timestamp: "1762202070.000000000",
+          transfers: [
+            { account: mockAddress, amount: -500 },
+            { account: "0.0.99", amount: 500 },
+          ],
+        },
+        {
+          consensus_timestamp: "1762202072.000000000",
+          transfers: [
+            { account: mockAddress, amount: 300 },
+            { account: "0.0.100", amount: -300 },
+          ],
+        },
+      ] as HederaMirrorTransaction[];
+
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce(
+        mockTransactions,
+      );
+
+      const result = await calculateUncommittedBalanceChange({
+        address: mockAddress,
+        startTimestamp: mockStartTimestamp,
+        endTimestamp: mockEndTimestamp,
+      });
+
+      expect(result).toEqual(new BigNumber(1800)); // 2000 - 500 + 300
+    });
+
+    it("should ignore transfers for other accounts", async () => {
+      const mockTransactions = [
+        {
+          consensus_timestamp: "1762202065.000000000",
+          transfers: [
+            { account: "0.0.98", amount: 5000 },
+            { account: "0.0.99", amount: -5000 },
+          ],
+        },
+        {
+          consensus_timestamp: "1762202070.000000000",
+          transfers: [
+            { account: mockAddress, amount: 1000 },
+            { account: "0.0.100", amount: -1000 },
+          ],
+        },
+      ] as HederaMirrorTransaction[];
+
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce(
+        mockTransactions,
+      );
+
+      const result = await calculateUncommittedBalanceChange({
+        address: mockAddress,
+        startTimestamp: mockStartTimestamp,
+        endTimestamp: mockEndTimestamp,
+      });
+
+      expect(result).toEqual(new BigNumber(1000));
+    });
+
+    it("should return 0 when timestamps are equal or invalid", async () => {
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce([]);
+
+      const [resultEqual, resultInvalid] = await Promise.all([
+        calculateUncommittedBalanceChange({
+          address: mockAddress,
+          startTimestamp: mockStartTimestamp,
+          endTimestamp: mockStartTimestamp,
+        }),
+        calculateUncommittedBalanceChange({
+          address: mockAddress,
+          startTimestamp: mockEndTimestamp,
+          endTimestamp: mockStartTimestamp,
+        }),
+      ]);
+
+      expect(resultEqual).toEqual(new BigNumber(0));
+      expect(resultInvalid).toEqual(new BigNumber(0));
+    });
+  });
+
   describe("analyzeStakingOperation", () => {
     const mockAddress = "0.0.12345";
     const mockTimestamp = "1762202064.065172388";
@@ -979,13 +1114,14 @@ describe("logic utils", () => {
     } as HederaMirrorTransaction;
 
     beforeEach(() => {
-      jest.clearAllMocks();
+      jest.resetAllMocks();
     });
 
     it("detects DELEGATE operation when staking starts", async () => {
       const accountBefore = getMockedMirrorAccount({ staked_node_id: null });
       const accountAfter = getMockedMirrorAccount({ staked_node_id: 5 });
 
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce([]);
       (apiClient.getAccount as jest.Mock)
         .mockResolvedValueOnce(accountBefore)
         .mockResolvedValueOnce(accountAfter);
@@ -998,6 +1134,7 @@ describe("logic utils", () => {
         targetStakingNodeId: 5,
         stakedAmount: BigInt(1000),
       });
+      expect(apiClient.getAccount).toHaveBeenCalledTimes(2);
       expect(apiClient.getAccount).toHaveBeenCalledWith(mockAddress, `lt:${mockTimestamp}`);
       expect(apiClient.getAccount).toHaveBeenCalledWith(mockAddress, `eq:${mockTimestamp}`);
     });
@@ -1006,6 +1143,7 @@ describe("logic utils", () => {
       const accountBefore = getMockedMirrorAccount({ staked_node_id: 5 });
       const accountAfter = getMockedMirrorAccount({ staked_node_id: null });
 
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce([]);
       (apiClient.getAccount as jest.Mock)
         .mockResolvedValueOnce(accountBefore)
         .mockResolvedValueOnce(accountAfter);
@@ -1024,6 +1162,7 @@ describe("logic utils", () => {
       const accountBefore = getMockedMirrorAccount({ staked_node_id: 3 });
       const accountAfter = getMockedMirrorAccount({ staked_node_id: 10 });
 
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce([]);
       (apiClient.getAccount as jest.Mock)
         .mockResolvedValueOnce(accountBefore)
         .mockResolvedValueOnce(accountAfter);
@@ -1038,6 +1177,51 @@ describe("logic utils", () => {
       });
     });
 
+    it("calculates correct staked amount with uncommitted transactions", async () => {
+      const mockBalance = { balance: 1000000, timestamp: "1762202060.000000000", tokens: [] };
+      const mockAccountBefore = getMockedMirrorAccount({
+        account: mockAddress,
+        staked_node_id: null,
+        balance: mockBalance,
+      });
+      const mockAccountAfter = getMockedMirrorAccount({
+        account: mockAddress,
+        staked_node_id: 5,
+        balance: mockBalance,
+      });
+      const mockTransactionsMissingInBalance = [
+        {
+          consensus_timestamp: `${Math.floor(Number(mockBalance.timestamp)) + 5}.000000000`,
+          transfers: [
+            { account: mockAddress, amount: -100000 },
+            { account: "0.0.98", amount: 100000 },
+          ],
+        },
+      ] as HederaMirrorTransaction[];
+
+      (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValueOnce(
+        mockTransactionsMissingInBalance,
+      );
+      (apiClient.getAccount as jest.Mock)
+        .mockResolvedValueOnce(mockAccountBefore)
+        .mockResolvedValueOnce(mockAccountAfter);
+
+      const result = await analyzeStakingOperation(mockAddress, mockTx);
+
+      expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledTimes(1);
+      expect(apiClient.getTransactionsByTimestampRange).toHaveBeenCalledWith({
+        address: mockAddress,
+        startTimestamp: `gt:${mockAccountBefore.balance.timestamp}`,
+        endTimestamp: `lte:${mockTimestamp}`,
+      });
+      expect(result).toEqual({
+        operationType: "DELEGATE",
+        previousStakingNodeId: null,
+        targetStakingNodeId: 5,
+        stakedAmount: BigInt(900000),
+      });
+    });
+
     it("returns null for regular account update (both null)", async () => {
       const accountBefore = getMockedMirrorAccount({ staked_node_id: null });
       const accountAfter = getMockedMirrorAccount({ staked_node_id: null });

package/src/logic/utils.ts

@@ -22,6 +22,7 @@ import {
   HEDERA_TRANSACTION_MODES,
   SYNTHETIC_BLOCK_WINDOW_SECONDS,
   TINYBAR_SCALE,
+  OP_TYPES_EXCLUDING_FEES,
 } from "../constants";
 import { apiClient } from "../network/api";
 import type {
@@ -69,7 +70,7 @@ export const getOperationValue = ({
     return BigInt(0);
   }
 
-  if (asset.type === "native" && operation.type === "OUT") {
+  if (asset.type === "native" && OP_TYPES_EXCLUDING_FEES.includes(operation.type)) {
     return BigInt(operation.value.toFixed(0)) - BigInt(operation.fee.toFixed(0));
   }
 
@@ -364,16 +365,17 @@ export const formatTransactionId = (transactionId: TransactionId): string => {
 };
 
 /**
- * Converts a Hedera account ID (e.g. "0.0.1234") into its corresponding EVM address in hexadecimal format.
- * If the conversion fails, it returns null.
+ * Fetches EVM address for given Hedera account ID (e.g. "0.0.1234").
+ * It returns null if the fetch fails.
  *
  * @param address - Hedera account ID in the format `shard.realm.num`
- * @returns the long-zero EVM address (`0x...`) or null if conversion fails
+ * @returns EVM address (`0x...`) or null if fetch fails
  */
-export const toEVMAddress = (accountId: string) => {
+export const toEVMAddress = async (accountId: string): Promise<string | null> => {
   try {
-    const evmAddress = "0x" + AccountId.fromString(accountId).toEvmAddress();
-    return evmAddress;
+    const account = await apiClient.getAccount(accountId);
+
+    return account.evm_address;
   } catch {
     return null;
   }
@@ -504,6 +506,48 @@ export const calculateAPY = (rewardRateStart: number): number => {
   return annualRate;
 };
 
+/**
+ * Calculates the uncommitted balance change for an account between two timestamps.
+ *
+ * This function handles the timing mismatch between Mirror Node balance snapshots and actual transactions.
+ * Balance snapshots are taken at regular intervals, not at every transaction, so querying by exact timestamp
+ * may return a snapshot from before moment you need.
+ *
+ * @param address - Hedera account ID (e.g., "0.0.12345")
+ * @param startTimestamp - Start of the time range (exclusive, format: "1234567890.123456789")
+ * @param endTimestamp - End of the time range (inclusive, format: "1234567890.123456789")
+ * @returns The net balance change as BigInt (sum of all transfers to/from the account)
+ */
+export const calculateUncommittedBalanceChange = async ({
+  address,
+  startTimestamp,
+  endTimestamp,
+}: {
+  address: string;
+  startTimestamp: string;
+  endTimestamp: string;
+}): Promise<BigNumber> => {
+  if (Number(startTimestamp) >= Number(endTimestamp)) {
+    return new BigNumber(0);
+  }
+
+  const uncommittedTransactions = await apiClient.getTransactionsByTimestampRange({
+    address,
+    startTimestamp: `gt:${startTimestamp}`,
+    endTimestamp: `lte:${endTimestamp}`,
+  });
+
+  // Sum all balance changes from transfers related to this account
+  const uncommittedBalanceChange = uncommittedTransactions.reduce((total, tx) => {
+    const transfers = tx.transfers ?? [];
+    const relevantTransfers = transfers.filter(t => t.account === address);
+    const netChange = relevantTransfers.reduce((sum, t) => sum.plus(t.amount), new BigNumber(0));
+    return total.plus(netChange);
+  }, new BigNumber(0));
+
+  return uncommittedBalanceChange;
+};
+
 /**
  * Hedera uses the AccountUpdateTransaction for multiple purposes, including staking operations.
  * Mirror node classifies all such transactions under the same name: "CRYPTOUPDATEACCOUNT".
@@ -517,6 +561,16 @@ export const calculateAPY = (rewardRateStart: number): number => {
  * 1. Fetching the account state BEFORE the transaction (using lt: timestamp filter)
  * 2. Fetching the account state AFTER the transaction (using eq: timestamp filter)
  * 3. Comparing the staked_node_id field to determine what changed
+ * 4. Calculating the actual staked amount by replaying uncommitted transactions between
+ *    the latest balance snapshot and the staking operation to handle snapshot timing mismatches
+ *
+ * @performance
+ * Makes 3 API calls per operation:
+ * - account state before
+ * - account state after
+ * - transaction history based on latest balance snapshot
+ *
+ * Batching would complicate code for minimal gain given low staking op frequency.
  */
 export const analyzeStakingOperation = async (
   address: string,
@@ -552,10 +606,19 @@ export const analyzeStakingOperation = async (
     return null;
   }
 
+  // calculate uncommitted balance changes between the last snapshot and the staking tx
+  const uncommittedBalanceChange = await calculateUncommittedBalanceChange({
+    address,
+    startTimestamp: accountAfter.balance.timestamp,
+    endTimestamp: mirrorTx.consensus_timestamp,
+  });
+
+  const actualStakedAmount = uncommittedBalanceChange.plus(accountAfter.balance.balance);
+
   return {
     operationType,
     previousStakingNodeId,
     targetStakingNodeId,
-    stakedAmount: BigInt(accountAfter.balance.balance), // always entire balance on Hedera (fully liquid)
+    stakedAmount: BigInt(actualStakedAmount.toString()), // always entire balance on Hedera (fully liquid)
   };
 };

package/src/network/api.test.ts

@@ -425,14 +425,33 @@ describe("getTransactionsByTimestampRange", () => {
     jest.resetAllMocks();
   });
 
+  it("should include account.id query param if address is provided", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({ transactions: [], links: { next: null } }),
+    );
+
+    await apiClient.getTransactionsByTimestampRange({
+      address: "0.0.1234",
+      startTimestamp: "gte:1000.000000000",
+      endTimestamp: "lt:2000.000000000",
+    });
+
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+    expect(requestUrl).toContain("account.id=0.0.1234");
+  });
+
   it("should include correct query params with timestamp range", async () => {
     mockedNetwork.mockResolvedValueOnce(
       getMockResponse({ transactions: [], links: { next: null } }),
     );
 
-    await apiClient.getTransactionsByTimestampRange("1000.000000000", "2000.000000000");
+    await apiClient.getTransactionsByTimestampRange({
+      startTimestamp: "gte:1000.000000000",
+      endTimestamp: "lt:2000.000000000",
+    });
 
     const requestUrl = mockedNetwork.mock.calls[0][0].url;
+    expect(requestUrl).not.toContain("account.id=");
     expect(requestUrl).toContain("timestamp=gte%3A1000.000000000");
     expect(requestUrl).toContain("timestamp=lt%3A2000.000000000");
     expect(requestUrl).toContain("limit=100");
@@ -444,10 +463,10 @@ describe("getTransactionsByTimestampRange", () => {
       getMockResponse({ transactions: [], links: { next: null } }),
     );
 
-    const result = await apiClient.getTransactionsByTimestampRange(
-      "1000.000000000",
-      "2000.000000000",
-    );
+    const result = await apiClient.getTransactionsByTimestampRange({
+      startTimestamp: "gte:1000.000000000",
+      endTimestamp: "lt:2000.000000000",
+    });
 
     expect(result).toEqual([]);
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
@@ -464,10 +483,10 @@ describe("getTransactionsByTimestampRange", () => {
       }),
     );
 
-    const result = await apiClient.getTransactionsByTimestampRange(
-      "1000.000000000",
-      "2000.000000000",
-    );
+    const result = await apiClient.getTransactionsByTimestampRange({
+      startTimestamp: "gte:1000.000000000",
+      endTimestamp: "lt:2000.000000000",
+    });
 
     expect(result.map(tx => tx.consensus_timestamp)).toEqual(["1500.123456789", "1750.987654321"]);
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
@@ -494,10 +513,10 @@ describe("getTransactionsByTimestampRange", () => {
         }),
       );
 
-    const result = await apiClient.getTransactionsByTimestampRange(
-      "1000.000000000",
-      "2000.000000000",
-    );
+    const result = await apiClient.getTransactionsByTimestampRange({
+      startTimestamp: "gte:1000.000000000",
+      endTimestamp: "lt:2000.000000000",
+    });
 
     expect(result.map(tx => tx.consensus_timestamp)).toEqual([
       "1100.000000000",
@@ -528,10 +547,10 @@ describe("getTransactionsByTimestampRange", () => {
         }),
       );
 
-    const result = await apiClient.getTransactionsByTimestampRange(
-      "1000.000000000",
-      "2000.000000000",
-    );
+    const result = await apiClient.getTransactionsByTimestampRange({
+      startTimestamp: "gte:1000.000000000",
+      endTimestamp: "lt:2000.000000000",
+    });
 
     expect(result.map(tx => tx.consensus_timestamp)).toEqual(["1100.000000000", "1300.000000000"]);
     expect(mockedNetwork).toHaveBeenCalledTimes(3);

package/src/network/api.ts

@@ -262,18 +262,24 @@ async function estimateContractCallGas(
   return new BigNumber(res.data.result);
 }
 
-async function getTransactionsByTimestampRange(
-  startTimestamp: string,
-  endTimestamp: string,
-): Promise<HederaMirrorTransaction[]> {
+async function getTransactionsByTimestampRange({
+  address,
+  startTimestamp,
+  endTimestamp,
+}: {
+  address?: string;
+  startTimestamp: `${string}:${string}`;
+  endTimestamp: `${string}:${string}`;
+}): Promise<HederaMirrorTransaction[]> {
   const transactions: HederaMirrorTransaction[] = [];
   const params = new URLSearchParams({
     limit: "100",
     order: "desc",
+    ...(address && { "account.id": address }),
   });
 
-  params.append("timestamp", `gte:${startTimestamp}`);
-  params.append("timestamp", `lt:${endTimestamp}`);
+  params.append("timestamp", startTimestamp);
+  params.append("timestamp", endTimestamp);
 
   let nextPath: string | null = `/api/v1/transactions?${params.toString()}`;
 

package/src/network/thirdweb.test.ts

@@ -1,10 +1,13 @@
 import { pad } from "viem";
 import network from "@ledgerhq/live-network";
+import { apiClient } from "./api";
 import { getMockedThirdwebTransaction } from "../test/fixtures/thirdweb.fixture";
 import { getMockResponse } from "../test/fixtures/common.fixture";
 import { thirdwebClient } from "./thirdweb";
 
 jest.mock("@ledgerhq/live-network");
+jest.mock("./api");
+
 const mockedNetwork = jest.mocked(network);
 
 const mockedERC20Transaction = getMockedThirdwebTransaction();
@@ -130,6 +133,11 @@ describe("fetchERC20Transactions", () => {
 describe("getERC20TransactionsForAccount", () => {
   beforeEach(() => {
     jest.clearAllMocks();
+
+    (apiClient.getAccount as jest.Mock).mockImplementation(address => ({
+      address,
+      evm_address: "0x0000000000000000000000000000000000012345",
+    }));
   });
 
   it("should return empty array without balance tokens list", async () => {

package/src/network/thirdweb.ts

@@ -56,7 +56,7 @@ async function getERC20TransactionsForAccount({
   transactionFetcher?: typeof fetchERC20Transactions; // optional dependency injection for testing
 }): Promise<HederaThirdwebTransaction[]> {
   const allTransactions: HederaThirdwebTransaction[] = [];
-  const evmAddress = toEVMAddress(address);
+  const evmAddress = await toEVMAddress(address);
 
   if (contractAddresses.length === 0) {
     return allTransactions;

package/src/test/fixtures/account.fixture.ts

@@ -140,6 +140,9 @@ export const MAINNET_TEST_ACCOUNTS = {
     associatedTokenWithoutBalance: "0.0.7243470",
     notAssociatedToken: "0.0.3176721",
   },
+  withQuickBalanceChanges: {
+    accountId: "0.0.10176637",
+  },
   activeStaking: {
     accountId: "0.0.8835924",
     publicKey: "34e26415574250721e8869bd33ea2678c2bbccff5fc70bd8b0ec9239295fd2cf",

package/src/test/fixtures/mirror.fixture.ts

@@ -23,6 +23,7 @@ export const getMockedMirrorAccount = (
 ): HederaMirrorAccount => {
   return {
     account: "0.0.12345",
+    evm_address: "0x0000000000000000000000000000000000012345",
     balance: {
       balance: 1000,
       timestamp: "1764932745.835883000",

package/src/types/mirror.ts

@@ -46,6 +46,7 @@ export interface HederaMirrorAccount {
   max_automatic_token_associations: number;
   staked_node_id: number | null;
   pending_reward: number;
+  evm_address: string;
   balance: {
     balance: number;
     timestamp: string;