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

package/src/network/api.test.ts

@@ -1,6 +1,12 @@
+import BigNumber from "bignumber.js";
 import network from "@ledgerhq/live-network";
 import { apiClient } from "./api";
 import { getMockResponse } from "../test/fixtures/network.fixture";
+import type {
+  HederaMirrorContractCallResult,
+  HederaMirrorNetworkFees,
+  HederaMirrorTransaction,
+} from "../types";
 
 jest.mock("@ledgerhq/live-network");
 const mockedNetwork = jest.mocked(network);
@@ -10,7 +16,7 @@ describe("getAccountTransactions", () => {
     jest.resetAllMocks();
   });
 
-  test("should include 'account.id', 'limit=100' and 'order=desc' query params", async () => {
+  it("should include 'account.id', 'limit=100' and 'order=desc' query params", async () => {
     mockedNetwork.mockResolvedValueOnce(
       getMockResponse({ transactions: [], links: { next: null } }),
     );
@@ -27,7 +33,7 @@ describe("getAccountTransactions", () => {
     expect(requestUrl).toContain("order=desc");
   });
 
-  test("should keep fetching if fetchAllPages is set and links.next is present", async () => {
+  it("should keep fetching if fetchAllPages is set and links.next is present", async () => {
     mockedNetwork
       .mockResolvedValueOnce(
         getMockResponse({
@@ -72,7 +78,7 @@ describe("getAccountTransactions", () => {
     expect(mockedNetwork).toHaveBeenCalledTimes(5);
   });
 
-  test("should paginate if fetchAllPages is not set", async () => {
+  it("should paginate if fetchAllPages is not set", async () => {
     mockedNetwork
       .mockResolvedValueOnce(
         getMockResponse({
@@ -192,3 +198,205 @@ describe("getAccountTokens", () => {
     expect(mockedNetwork).toHaveBeenCalledTimes(2);
   });
 });
+
+describe("getNetworkFees", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the correct endpoint and return network fees", async () => {
+    const mockedResults: HederaMirrorNetworkFees = {
+      fees: [{ gas: 39, transaction_type: "ContractCall" }],
+      timestamp: "1758733200.632122898",
+    };
+
+    mockedNetwork.mockResolvedValueOnce(getMockResponse(mockedResults));
+
+    const result = await apiClient.getNetworkFees();
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(mockedResults);
+    expect(requestUrl).toContain("/api/v1/network/fees");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("getContractCallResult", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the correct endpoint and return results for contract call", async () => {
+    const mockedResults: HederaMirrorContractCallResult = {
+      contract_id: "0.0.4321",
+      block_gas_used: 100,
+      gas_consumed: 200,
+      gas_limit: 10000,
+      gas_used: 150,
+      timestamp: "xxxxxxxxx",
+    };
+
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        contract_id: "0.0.4321",
+        block_gas_used: 100,
+        gas_consumed: 200,
+        gas_limit: 10000,
+        gas_used: 150,
+        timestamp: "xxxxxxxxx",
+      }),
+    );
+
+    const result = await apiClient.getContractCallResult(
+      "0xa9059cbb000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000186a0",
+    );
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(mockedResults);
+    expect(requestUrl).toContain("/api/v1/contracts/results");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("findTransactionByContractCall", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the correct endpoint and return transaction details", async () => {
+    const mockedResults: HederaMirrorTransaction = {
+      transfers: [],
+      token_transfers: [],
+      charged_tx_fee: 100,
+      transaction_id: "xxxxxxxxxxxxxx",
+      transaction_hash: "xxxxxxxxxxxxx",
+      consensus_timestamp: "xxxxxxxxxxxxx",
+      result: "xxxxxxxxxxxxx",
+      entity_id: "0.0.1234",
+      name: "CONTRACTCALL",
+    };
+
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        transactions: [mockedResults],
+      }),
+    );
+
+    const result = await apiClient.findTransactionByContractCall(
+      "xxxxxxxxxxxxxxxxxxxx",
+      "0.0.1234",
+    );
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(mockedResults);
+    expect(requestUrl).toContain("/api/v1/transactions?timestamp=");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call the correct endpoint and return null for non existing contract calls", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        transactions: [
+          {
+            transfers: [],
+            token_transfers: [],
+            charged_tx_fee: 100,
+            transaction_hash: "xxxxxxxxxxxxx",
+            consensus_timestamp: "xxxxxxxxxxxxx",
+            result: "xxxxxxxxxxxxx",
+            entity_id: "0.0.1234",
+            name: "NOT_CONTRACTCALL",
+          },
+          {
+            transfers: [],
+            token_transfers: [],
+            charged_tx_fee: 100,
+            transaction_hash: "xxxxxxxxxxxxx",
+            consensus_timestamp: "xxxxxxxxxxxxx",
+            result: "xxxxxxxxxxxxx",
+            entity_id: "0.0.1111",
+            name: "CONTRACTCALL",
+          },
+        ],
+      }),
+    );
+
+    const result = await apiClient.findTransactionByContractCall(
+      "xxxxxxxxxxxxxxxxxxxx",
+      "0.0.1234",
+    );
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(null);
+    expect(requestUrl).toContain("/api/v1/transactions?timestamp=");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call the correct endpoint and return null for empty transactions list", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        transactions: [],
+      }),
+    );
+
+    const result = await apiClient.findTransactionByContractCall(
+      "xxxxxxxxxxxxxxxxxxxx",
+      "0.0.1234",
+    );
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(null);
+    expect(requestUrl).toContain("/api/v1/transactions?timestamp=");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("getERC20Balance", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the correct endpoint and return the contract balance", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        result: "1000000000",
+      }),
+    );
+
+    const result = await apiClient.getERC20Balance(
+      "0x0000000000000000000000000000000000000001",
+      "0x0000000000000000000000000000000000000002",
+    );
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(BigNumber("1000000000"));
+    expect(requestUrl).toContain("/api/v1/contracts/call");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("estimateContractCallGas", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the correct endpoint and return estimated contract call gas", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        result: "1000000000",
+      }),
+    );
+
+    const result = await apiClient.estimateContractCallGas(
+      "0x0000000000000000000000000000000000000001",
+      "0x0000000000000000000000000000000000000002",
+      "0xa9059cbb000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000186a0",
+      BigInt(1000),
+    );
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result).toEqual(BigNumber("1000000000"));
+    expect(requestUrl).toContain("/api/v1/contracts/call");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+});

package/src/network/api.ts

@@ -1,3 +1,5 @@
+import BigNumber from "bignumber.js";
+import { encodeFunctionData, erc20Abi } from "viem";
 import network from "@ledgerhq/live-network";
 import type { LiveNetworkResponse } from "@ledgerhq/live-network/network";
 import { getEnv } from "@ledgerhq/live-env";
@@ -10,23 +12,21 @@ import type {
   HederaMirrorAccountsResponse,
   HederaMirrorToken,
   HederaMirrorTransaction,
+  HederaMirrorNetworkFees,
+  HederaMirrorContractCallResult,
+  HederaMirrorContractCallBalance,
+  HederaMirrorContractCallEstimate,
 } from "../types";
 
-const getMirrorApiUrl = (): string => getEnv("API_HEDERA_MIRROR");
-
-const fetch = <Result>(path: string) => {
-  return network<Result>({
-    method: "GET",
-    url: `${getMirrorApiUrl()}${path}`,
-  });
-};
+const API_URL = getEnv("API_HEDERA_MIRROR");
 
 async function getAccountsForPublicKey(publicKey: string): Promise<HederaMirrorAccount[]> {
   let res;
   try {
-    res = await fetch<HederaMirrorAccountsResponse>(
-      `/api/v1/accounts?account.publicKey=${publicKey}&balance=true&limit=100`,
-    );
+    res = await network<HederaMirrorAccountsResponse>({
+      method: "GET",
+      url: `${API_URL}/api/v1/accounts?account.publicKey=${publicKey}&balance=true&limit=100`,
+    });
   } catch (e: unknown) {
     if (e instanceof LedgerAPI4xx) return [];
     throw e;
@@ -39,7 +39,10 @@ async function getAccountsForPublicKey(publicKey: string): Promise<HederaMirrorA
 
 async function getAccount(address: string): Promise<HederaMirrorAccount> {
   try {
-    const res = await fetch<HederaMirrorAccount>(`/api/v1/accounts/${address}`);
+    const res = await network<HederaMirrorAccount>({
+      method: "GET",
+      url: `${API_URL}/api/v1/accounts/${address}`,
+    });
     const account = res.data;
 
     return account;
@@ -83,16 +86,19 @@ async function getAccountTransactions({
   }
 
   let nextCursor: string | null = null;
-  let nextUrl: string | null = `/api/v1/transactions?${params.toString()}`;
+  let nextPath: string | null = `/api/v1/transactions?${params.toString()}`;
 
   // WARNING: don't break the loop when `transactions` array is empty but `links.next` is present
   // the mirror node API enforces a 60-day max time range per query, even if `timestamp` param is set
   // see: https://hedera.com/blog/changes-to-the-hedera-operated-mirror-node
-  while (nextUrl) {
-    const res: LiveNetworkResponse<HederaMirrorTransactionsResponse> = await fetch(nextUrl);
+  while (nextPath) {
+    const res: LiveNetworkResponse<HederaMirrorTransactionsResponse> = await network({
+      method: "GET",
+      url: `${API_URL}${nextPath}`,
+    });
     const newTransactions = res.data.transactions;
     transactions.push(...newTransactions);
-    nextUrl = res.data.links.next;
+    nextPath = res.data.links.next;
 
     // stop fetching if pagination mode is used and we reached the limit
     if (!fetchAllPages && transactions.length >= limit) {
@@ -106,7 +112,7 @@ async function getAccountTransactions({
   }
 
   // set the next cursor only if we have more transactions to fetch
-  if (!fetchAllPages && nextUrl) {
+  if (!fetchAllPages && nextPath) {
     const lastTx = transactions.at(-1);
     nextCursor = lastTx?.consensus_timestamp ?? null;
   }
@@ -120,13 +126,16 @@ async function getAccountTokens(address: string): Promise<HederaMirrorToken[]> {
     limit: "100",
   });
 
-  let nextUrl: string | null = `/api/v1/accounts/${address}/tokens?${params.toString()}`;
+  let nextPath: string | null = `/api/v1/accounts/${address}/tokens?${params.toString()}`;
 
-  while (nextUrl) {
-    const res: LiveNetworkResponse<HederaMirrorAccountTokensResponse> = await fetch(nextUrl);
+  while (nextPath) {
+    const res: LiveNetworkResponse<HederaMirrorAccountTokensResponse> = await network({
+      method: "GET",
+      url: `${API_URL}${nextPath}`,
+    });
     const newTokens = res.data.tokens;
     tokens.push(...newTokens);
-    nextUrl = res.data.links.next;
+    nextPath = res.data.links.next;
   }
 
   return tokens;
@@ -138,9 +147,10 @@ async function getLatestTransaction(): Promise<HederaMirrorTransaction> {
     order: "desc",
   });
 
-  const res = await fetch<HederaMirrorTransactionsResponse>(
-    `/api/v1/transactions?${params.toString()}`,
-  );
+  const res = await network<HederaMirrorTransactionsResponse>({
+    method: "GET",
+    url: `${API_URL}/api/v1/transactions?${params.toString()}`,
+  });
   const transaction = res.data.transactions[0];
 
   if (!transaction) {
@@ -150,10 +160,94 @@ async function getLatestTransaction(): Promise<HederaMirrorTransaction> {
   return transaction;
 }
 
+async function getNetworkFees(): Promise<HederaMirrorNetworkFees> {
+  const res = await network<HederaMirrorNetworkFees>({
+    method: "GET",
+    url: `${API_URL}/api/v1/network/fees`,
+  });
+
+  return res.data;
+}
+
+async function getContractCallResult(
+  transactionHash: string,
+): Promise<HederaMirrorContractCallResult> {
+  const res = await network<HederaMirrorContractCallResult>({
+    method: "GET",
+    url: `${API_URL}/api/v1/contracts/results/${transactionHash}`,
+  });
+
+  return res.data;
+}
+
+async function findTransactionByContractCall(
+  timestamp: string,
+  contractId: string,
+): Promise<HederaMirrorTransaction | null> {
+  const res = await network<HederaMirrorTransactionsResponse>({
+    method: "GET",
+    url: `${API_URL}/api/v1/transactions?timestamp=${timestamp}`,
+  });
+  const transactions = res.data.transactions;
+
+  return transactions.find(el => el.name === "CONTRACTCALL" && el.entity_id === contractId) ?? null;
+}
+
+async function getERC20Balance(
+  accountEvmAddress: string,
+  contractEvmAddress: string,
+): Promise<BigNumber> {
+  const res = await network<HederaMirrorContractCallBalance>({
+    method: "POST",
+    url: `${API_URL}/api/v1/contracts/call`,
+    data: {
+      block: "latest",
+      to: contractEvmAddress,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [accountEvmAddress as `0x${string}`],
+      }),
+    },
+  });
+
+  return new BigNumber(res.data.result);
+}
+
+async function estimateContractCallGas(
+  senderEvmAddress: string,
+  recipientEvmAddress: string,
+  contractEvmAddress: string,
+  amount: bigint,
+): Promise<BigNumber> {
+  const res = await network<HederaMirrorContractCallEstimate>({
+    method: "POST",
+    url: `${API_URL}/api/v1/contracts/call`,
+    data: {
+      block: "latest",
+      estimate: true,
+      from: senderEvmAddress,
+      to: contractEvmAddress,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "transfer",
+        args: [recipientEvmAddress as `0x${string}`, amount],
+      }),
+    },
+  });
+
+  return new BigNumber(res.data.result);
+}
+
 export const apiClient = {
   getAccountsForPublicKey,
   getAccount,
   getAccountTokens,
   getAccountTransactions,
   getLatestTransaction,
+  getNetworkFees,
+  getContractCallResult,
+  findTransactionByContractCall,
+  getERC20Balance,
+  estimateContractCallGas,
 };

package/src/network/rpc.test.ts

@@ -2,6 +2,7 @@ import { Client, Transaction, TransactionResponse } from "@hashgraph/sdk";
 import { rpcClient } from "./rpc";
 
 const mockClient = {
+  close: jest.fn(),
   setMaxNodesPerTransaction: jest.fn().mockReturnThis(),
   setNetwork: jest.fn().mockReturnThis(),
 } as unknown as Client;

package/src/network/rpc.ts

@@ -15,6 +15,7 @@ function getInstance(): Client {
 
 // for testing purposes only, used to reset singleton client instance
 function _resetInstance() {
+  _hederaClient?.close();
   _hederaClient = null;
 }
 

package/src/network/thirdweb.test.ts

@@ -0,0 +1,188 @@
+import { pad } from "viem";
+import network from "@ledgerhq/live-network";
+import { getMockedThirdwebTransaction } from "../test/fixtures/thirdweb.fixture";
+import { getMockResponse } from "../test/fixtures/common.fixture";
+import { thirdwebClient } from "./thirdweb";
+
+jest.mock("@ledgerhq/live-network");
+const mockedNetwork = jest.mocked(network);
+
+const mockedERC20Transaction = getMockedThirdwebTransaction();
+const mockedERC20TokenAddress1 = "0x0000000000000000000000000000000000000001";
+const mockedERC20TokenAddress2 = "0x0000000000000000000000000000000000000002";
+const mockedTopic0Address = pad("0x0000000000000000000000000000000000000000");
+const mockedTopic1Address = pad("0x0000000000000000000000000000000000000003");
+
+describe("fetchERC20Transactions", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should include 'page', 'limit=1000' and filterTopic query params", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        result: {
+          events: [],
+          pagination: { limit: 1000, page: 1, totalCount: 0 },
+        },
+      }),
+    );
+
+    const params = {
+      limit: "1000",
+      page: "1",
+      filterTopic0: mockedTopic0Address,
+      filterTopic1: mockedTopic1Address,
+    };
+
+    await thirdwebClient.fetchERC20Transactions(mockedERC20TokenAddress1, params);
+
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+    expect(requestUrl).toContain("page=1");
+    expect(requestUrl).toContain("limit=1000");
+    expect(requestUrl).toContain(`filterTopic0=${mockedTopic0Address}`);
+    expect(requestUrl).toContain(`filterTopic1=${mockedTopic1Address}`);
+  });
+
+  it("should fire only once and return single element", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        result: {
+          events: [mockedERC20Transaction],
+          pagination: { limit: 1000, page: 1, totalCount: 1 },
+        },
+      }),
+    );
+
+    const params = {
+      limit: "1000",
+      page: "1",
+      filterTopic0: mockedTopic0Address,
+      filterTopic1: mockedTopic1Address,
+    };
+    const result = await thirdwebClient.fetchERC20Transactions(mockedERC20TokenAddress1, params);
+
+    expect(result).toHaveLength(1);
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should fire only once and return empty array", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        result: {
+          events: [],
+          pagination: { limit: 1000, page: 1, totalCount: 0 },
+        },
+      }),
+    );
+
+    const params = {
+      limit: "1000",
+      page: "1",
+      filterTopic0: mockedTopic0Address,
+      filterTopic1: mockedTopic1Address,
+    };
+    const result = await thirdwebClient.fetchERC20Transactions(mockedERC20TokenAddress1, params);
+
+    expect(result).toHaveLength(0);
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should keep fetching until returned events are fewer than requested limit", async () => {
+    mockedNetwork
+      .mockResolvedValueOnce(
+        getMockResponse({
+          result: {
+            events: [mockedERC20Transaction, mockedERC20Transaction],
+            pagination: { limit: 2, page: 1, totalCount: 2 },
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          result: {
+            events: [mockedERC20Transaction, mockedERC20Transaction],
+            pagination: { limit: 2, page: 2, totalCount: 2 },
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          result: {
+            events: [mockedERC20Transaction],
+            pagination: { limit: 2, page: 3, totalCount: 2 },
+          },
+        }),
+      );
+
+    const params = {
+      limit: "2",
+      filterTopic0: mockedTopic0Address,
+      filterTopic1: mockedTopic1Address,
+    };
+    const result = await thirdwebClient.fetchERC20Transactions(mockedERC20TokenAddress1, params);
+
+    expect(result).toHaveLength(5);
+    expect(mockedNetwork).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe("getERC20TransactionsForAccount", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return empty array without balance tokens list", async () => {
+    const result = await thirdwebClient.getERC20TransactionsForAccount({
+      address: "0.0.1234",
+      contractAddresses: [],
+      since: null,
+    });
+
+    expect(result).toHaveLength(0);
+  });
+
+  it("should return exactly 2 transactions (out & in)", async () => {
+    const mockFetcher = jest.fn().mockResolvedValue([mockedERC20Transaction]);
+
+    const result = await thirdwebClient.getERC20TransactionsForAccount({
+      address: "0.0.1234",
+      contractAddresses: [mockedERC20TokenAddress1],
+      since: null,
+      transactionFetcher: mockFetcher,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(mockFetcher).toHaveBeenCalledTimes(2);
+  });
+
+  it("should return exactly 4 transactions total for 2 tokens (out & in)", async () => {
+    const mockFetcher = jest.fn().mockResolvedValue([mockedERC20Transaction]);
+
+    const result = await thirdwebClient.getERC20TransactionsForAccount({
+      address: "0.0.1234",
+      contractAddresses: [mockedERC20TokenAddress1, mockedERC20TokenAddress2],
+      since: null,
+      transactionFetcher: mockFetcher,
+    });
+
+    expect(result).toHaveLength(4);
+    expect(mockFetcher).toHaveBeenCalledTimes(4);
+  });
+
+  it("should return exactly 4 transactions for single token (out & in)", async () => {
+    const mockFetcher = jest
+      .fn()
+      .mockResolvedValue([mockedERC20Transaction, mockedERC20Transaction]);
+
+    const result = await thirdwebClient.getERC20TransactionsForAccount({
+      address: "0.0.1234",
+      contractAddresses: [mockedERC20TokenAddress1],
+      since: null,
+      transactionFetcher: mockFetcher,
+    });
+
+    expect(result).toHaveLength(4);
+    expect(mockFetcher).toHaveBeenCalledTimes(2);
+  });
+});