@ledgerhq/coin-hedera 1.16.0-nightly.20251211024123 → 1.16.0-nightly.20251213023821

package/src/network/api.ts

@@ -4,6 +4,7 @@ import network from "@ledgerhq/live-network";
 import type { LiveNetworkResponse } from "@ledgerhq/live-network/network";
 import { getEnv } from "@ledgerhq/live-env";
 import { LedgerAPI4xx } from "@ledgerhq/errors";
+import { HEDERA_TRANSACTION_NAMES } from "../constants";
 import { HederaAddAccountError } from "../errors";
 import type {
   HederaMirrorAccountTokensResponse,
@@ -39,11 +40,28 @@ async function getAccountsForPublicKey(publicKey: string): Promise<HederaMirrorA
   return accounts;
 }
 
-async function getAccount(address: string): Promise<HederaMirrorAccount> {
+/**
+ * Fetches account information from the Hedera Mirror Node API, excluding transactions.
+ *
+ * @param address - The Hedera account ID (e.g., "0.0.12345")
+ * @param timestamp - Optional timestamp filter to get historical account state.
+ *                    Supports comparison operators:
+ *                    - "lt:1234567890.123456789" - state before the timestamp
+ *                    - "eq:1234567890.123456789" - state at the timestamp
+ *                    Used primarily for analyzing state changes in staking operations.
+ * @returns Promise resolving to account data
+ * @throws HederaAddAccountError if account not found (404)
+ */
+async function getAccount(address: string, timestamp?: string): Promise<HederaMirrorAccount> {
   try {
+    const params = new URLSearchParams({
+      transactions: "false",
+      ...(timestamp && { timestamp }),
+    });
+
     const res = await network<HederaMirrorAccount>({
       method: "GET",
-      url: `${API_URL}/api/v1/accounts/${address}`,
+      url: `${API_URL}/api/v1/accounts/${address}?${params.toString()}`,
     });
     const account = res.data;
 
@@ -57,6 +75,12 @@ async function getAccount(address: string): Promise<HederaMirrorAccount> {
   }
 }
 
+// keeps old behavior when all pages are fetched
+const getPaginationDirection = (fetchAllPages: boolean, order: string) => {
+  if (fetchAllPages) return "gt";
+  return order === "asc" ? "gt" : "lt";
+};
+
 async function getAccountTransactions({
   address,
   pagingToken,
@@ -77,14 +101,8 @@ async function getAccountTransactions({
     order,
   });
 
-  // keeps old behavior when all pages are fetched
-  const getTimestampDirection = () => {
-    if (fetchAllPages) return "gt";
-    return order === "asc" ? "gt" : "lt";
-  };
-
   if (pagingToken) {
-    params.append("timestamp", `${getTimestampDirection()}:${pagingToken}`);
+    params.append("timestamp", `${getPaginationDirection(fetchAllPages, order)}:${pagingToken}`);
   }
 
   let nextCursor: string | null = null;
@@ -191,8 +209,11 @@ async function findTransactionByContractCall(
     url: `${API_URL}/api/v1/transactions?timestamp=${timestamp}`,
   });
   const transactions = res.data.transactions;
+  const relatedTx = transactions.find(
+    el => el.name === HEDERA_TRANSACTION_NAMES.ContractCall && el.entity_id === contractId,
+  );
 
-  return transactions.find(el => el.name === "CONTRACTCALL" && el.entity_id === contractId) ?? null;
+  return relatedTx ?? null;
 }
 
 async function getERC20Balance(
@@ -269,13 +290,28 @@ async function getTransactionsByTimestampRange(
   return transactions;
 }
 
-async function getNodes(): Promise<HederaMirrorNode[]> {
+async function getNodes({
+  cursor,
+  limit = 100,
+  order = "desc",
+  fetchAllPages,
+}: {
+  cursor?: string;
+  limit?: number;
+  order?: "asc" | "desc";
+  fetchAllPages: boolean;
+}): Promise<{ nodes: HederaMirrorNode[]; nextCursor: string | null }> {
   const nodes: HederaMirrorNode[] = [];
   const params = new URLSearchParams({
-    order: "desc",
-    limit: "100",
+    order,
+    limit: limit.toString(),
   });
 
+  if (cursor) {
+    params.append("node.id", `${getPaginationDirection(fetchAllPages, order)}:${cursor}`);
+  }
+
+  let nextCursor: string | null = null;
   let nextPath: string | null = `/api/v1/network/nodes?${params.toString()}`;
 
   while (nextPath) {
@@ -286,9 +322,25 @@ async function getNodes(): Promise<HederaMirrorNode[]> {
     const newNodes = res.data.nodes;
     nodes.push(...newNodes);
     nextPath = res.data.links.next;
+
+    // stop fetching if pagination mode is used and we reached the limit
+    if (!fetchAllPages && nodes.length >= limit) {
+      break;
+    }
+  }
+
+  // ensure we don't exceed the limit in pagination mode
+  if (!fetchAllPages && nodes.length > limit) {
+    nodes.splice(limit);
+  }
+
+  // set the next cursor only if we have more nodes to fetch
+  if (!fetchAllPages && nextPath) {
+    const lastNode = nodes.at(-1);
+    nextCursor = lastNode?.node_id?.toString() ?? null;
   }
 
-  return nodes;
+  return { nodes, nextCursor };
 }
 
 export const apiClient = {

package/src/preload.ts

@@ -12,9 +12,9 @@ export const getPreloadStrategy = () => ({
 
 export async function preload(currency: CryptoCurrency): Promise<HederaPreloadData> {
   log("hedera/preload", "preloading hedera data...");
-  const nodes = await apiClient.getNodes();
+  const result = await apiClient.getNodes({ fetchAllPages: true });
 
-  const validators: HederaValidator[] = nodes.map(mirrorNode => {
+  const validators: HederaValidator[] = result.nodes.map(mirrorNode => {
     const minStake = new BigNumber(mirrorNode.min_stake);
     const maxStake = new BigNumber(mirrorNode.max_stake);
     const activeStake = new BigNumber(mirrorNode.stake_rewarded);

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

@@ -140,4 +140,12 @@ export const MAINNET_TEST_ACCOUNTS = {
     associatedTokenWithoutBalance: "0.0.7243470",
     notAssociatedToken: "0.0.3176721",
   },
+  activeStaking: {
+    accountId: "0.0.8835924",
+    publicKey: "34e26415574250721e8869bd33ea2678c2bbccff5fc70bd8b0ec9239295fd2cf",
+  },
+  inactiveStaking: {
+    accountId: "0.0.9806001",
+    publicKey: "0283ef0997da7161c9a3aec45c57f4e074cb67916c97c1e5339d9f988e702e0450",
+  },
 };

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

@@ -1,4 +1,5 @@
 import type {
+  HederaMirrorAccount,
   HederaMirrorCoinTransfer,
   HederaMirrorToken,
   HederaMirrorTokenTransfer,
@@ -17,6 +18,23 @@ export const getMockedMirrorToken = (overrides?: Partial<HederaMirrorToken>): He
   };
 };
 
+export const getMockedMirrorAccount = (
+  overrides?: Partial<HederaMirrorAccount>,
+): HederaMirrorAccount => {
+  return {
+    account: "0.0.12345",
+    balance: {
+      balance: 1000,
+      timestamp: "1764932745.835883000",
+      tokens: [],
+    },
+    max_automatic_token_associations: -1,
+    pending_reward: 0,
+    staked_node_id: null,
+    ...overrides,
+  };
+};
+
 export const createMirrorCoinTransfer = (
   account: string,
   amount: number,

package/src/types/bridge.ts

@@ -171,6 +171,7 @@ export type HederaOperationExtra = {
   memo?: string | null;
   targetStakingNodeId?: number | null;
   previousStakingNodeId?: number | null;
+  stakedAmount?: BigNumber;
 };
 
 export type HederaValidator = {

package/src/types/logic.ts

@@ -47,3 +47,10 @@ export interface OperationDetailsExtraField {
   key: string;
   value: string | number;
 }
+
+export interface StakingAnalysis {
+  operationType: OperationType;
+  targetStakingNodeId: number | null;
+  previousStakingNodeId: number | null;
+  stakedAmount: bigint;
+}

package/tsconfig.json

@@ -1,13 +1,18 @@
 {
-    "extends": "../../../tsconfig.base",
-    "compilerOptions": {
-      "declaration": true,
-      "declarationMap": true,
-      "downlevelIteration": true,
-      "lib": ["es2020", "dom"],
-      "exactOptionalPropertyTypes": true,
-      "module": "esnext",
-      "moduleResolution": "bundler",
-    },
-    "include": ["src/**/*"]
-  }
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "lib": [
+      "es2020",
+      "dom"
+    ],
+    "exactOptionalPropertyTypes": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+  },
+  "include": [
+    "src/**/*"
+  ]
+}