@ledgerhq/coin-hedera 1.16.0-nightly.20251212024049 → 1.16.0-nightly.20251215100948

package/src/logic/listOperations.ts

@@ -6,10 +6,21 @@ import type { Pagination } from "@ledgerhq/coin-framework/api/types";
 import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import { encodeAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/accountId";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { HEDERA_TRANSACTION_NAMES } from "../constants";
 import { apiClient } from "../network/api";
 import { parseTransfers } from "../network/utils";
-import type { HederaMirrorToken, HederaMirrorTransaction, HederaOperationExtra } from "../types";
-import { base64ToUrlSafeBase64, getMemoFromBase64, getSyntheticBlock } from "./utils";
+import type {
+  HederaMirrorToken,
+  HederaMirrorTransaction,
+  HederaOperationExtra,
+  StakingAnalysis,
+} from "../types";
+import {
+  analyzeStakingOperation,
+  base64ToUrlSafeBase64,
+  getMemoFromBase64,
+  getSyntheticBlock,
+} from "./utils";
 
 const txNameToCustomOperationType: Record<string, OperationType> = {
   TOKENASSOCIATE: "ASSOCIATE_TOKEN",
@@ -129,12 +140,14 @@ function processTransfers({
   ledgerAccountId,
   commonData,
   mirrorTokens,
+  stakingAnalysis,
 }: {
   rawTx: HederaMirrorTransaction;
   address: string;
   ledgerAccountId: string;
   commonData: ReturnType<typeof getCommonOperationData>;
   mirrorTokens: HederaMirrorToken[];
+  stakingAnalysis: StakingAnalysis | null;
 }): Operation<HederaOperationExtra>[] {
   const coinOperations: Operation<HederaOperationExtra>[] = [];
   const transfers = rawTx.transfers ?? [];
@@ -146,7 +159,17 @@ function processTransfers({
   const { type, value, senders, recipients } = parseTransfers(transfers, address);
   const { hash, fee, timestamp, blockHeight, blockHash, hasFailed } = commonData;
   const extra = { ...commonData.extra };
-  const operationType = txNameToCustomOperationType[rawTx.name] ?? type;
+  let operationType = txNameToCustomOperationType[rawTx.name] ?? type;
+
+  // update operation type and extra fields if staking analysis is available
+  if (stakingAnalysis) {
+    operationType = stakingAnalysis.operationType;
+    extra.previousStakingNodeId = stakingAnalysis.previousStakingNodeId;
+    extra.targetStakingNodeId = stakingAnalysis.targetStakingNodeId;
+    extra.stakedAmount = new BigNumber(stakingAnalysis.stakedAmount.toString());
+  }
+
+  // each transfer may trigger staking reward claim
   const stakingReward = rawTx.staking_reward_transfers.reduce((acc, transfer) => {
     const transferAmount = new BigNumber(transfer.amount);
 
@@ -256,6 +279,12 @@ export async function listOperations({
   for (const rawTx of mirrorResult.transactions) {
     const commonData = getCommonOperationData(rawTx, useEncodedHash, useSyntheticBlocks);
 
+    // try to distinguish staking operations for CRYPTOUPDATEACCOUNT transactions
+    const stakingAnalysis =
+      rawTx.name === HEDERA_TRANSACTION_NAMES.UpdateAccount
+        ? await analyzeStakingOperation(address, rawTx)
+        : null;
+
     // process token transfers
     const tokenResult = await processTokenTransfers({
       rawTx,
@@ -277,6 +306,7 @@ export async function listOperations({
         ledgerAccountId,
         commonData,
         mirrorTokens,
+        stakingAnalysis,
       });
 
       coinOperations.push(...newCoinOperations);

package/src/logic/utils.test.ts

@@ -20,9 +20,11 @@ import {
   getMockedHTSTokenCurrency,
 } from "../test/fixtures/currency.fixture";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
+import { getMockedMirrorAccount } from "../test/fixtures/mirror.fixture";
 import type {
   HederaAccount,
   HederaMemo,
+  HederaMirrorTransaction,
   HederaPreloadData,
   HederaTxData,
   HederaValidator,
@@ -60,6 +62,8 @@ import {
   getChecksum,
   mapIntentToSDKOperation,
   getOperationDetailsExtraFields,
+  calculateAPY,
+  analyzeStakingOperation,
 } from "./utils";
 
 jest.mock("../network/api");
@@ -951,4 +955,113 @@ describe("logic utils", () => {
       ]);
     });
   });
+
+  describe("calculateAPY", () => {
+    it("should calculate APY correctly for a typical reward rate", () => {
+      const result = calculateAPY(3538);
+
+      expect(result).toBeCloseTo(0.01291, 5);
+    });
+
+    it("should return 0 for zero reward rate", () => {
+      const result = calculateAPY(0);
+
+      expect(result).toBe(0);
+    });
+  });
+
+  describe("analyzeStakingOperation", () => {
+    const mockAddress = "0.0.12345";
+    const mockTimestamp = "1762202064.065172388";
+    const mockTx = {
+      consensus_timestamp: mockTimestamp,
+      name: "CRYPTOUPDATEACCOUNT",
+    } as HederaMirrorTransaction;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it("detects DELEGATE operation when staking starts", async () => {
+      const accountBefore = getMockedMirrorAccount({ staked_node_id: null });
+      const accountAfter = getMockedMirrorAccount({ staked_node_id: 5 });
+
+      (apiClient.getAccount as jest.Mock)
+        .mockResolvedValueOnce(accountBefore)
+        .mockResolvedValueOnce(accountAfter);
+
+      const result = await analyzeStakingOperation(mockAddress, mockTx);
+
+      expect(result).toEqual({
+        operationType: "DELEGATE",
+        previousStakingNodeId: null,
+        targetStakingNodeId: 5,
+        stakedAmount: BigInt(1000),
+      });
+      expect(apiClient.getAccount).toHaveBeenCalledWith(mockAddress, `lt:${mockTimestamp}`);
+      expect(apiClient.getAccount).toHaveBeenCalledWith(mockAddress, `eq:${mockTimestamp}`);
+    });
+
+    it("detects UNDELEGATE operation when staking stops", async () => {
+      const accountBefore = getMockedMirrorAccount({ staked_node_id: 5 });
+      const accountAfter = getMockedMirrorAccount({ staked_node_id: null });
+
+      (apiClient.getAccount as jest.Mock)
+        .mockResolvedValueOnce(accountBefore)
+        .mockResolvedValueOnce(accountAfter);
+
+      const result = await analyzeStakingOperation(mockAddress, mockTx);
+
+      expect(result).toEqual({
+        operationType: "UNDELEGATE",
+        previousStakingNodeId: 5,
+        targetStakingNodeId: null,
+        stakedAmount: BigInt(1000),
+      });
+    });
+
+    it("detects REDELEGATE operation when changing nodes", async () => {
+      const accountBefore = getMockedMirrorAccount({ staked_node_id: 3 });
+      const accountAfter = getMockedMirrorAccount({ staked_node_id: 10 });
+
+      (apiClient.getAccount as jest.Mock)
+        .mockResolvedValueOnce(accountBefore)
+        .mockResolvedValueOnce(accountAfter);
+
+      const result = await analyzeStakingOperation(mockAddress, mockTx);
+
+      expect(result).toEqual({
+        operationType: "REDELEGATE",
+        previousStakingNodeId: 3,
+        targetStakingNodeId: 10,
+        stakedAmount: BigInt(1000),
+      });
+    });
+
+    it("returns null for regular account update (both null)", async () => {
+      const accountBefore = getMockedMirrorAccount({ staked_node_id: null });
+      const accountAfter = getMockedMirrorAccount({ staked_node_id: null });
+
+      (apiClient.getAccount as jest.Mock)
+        .mockResolvedValueOnce(accountBefore)
+        .mockResolvedValueOnce(accountAfter);
+
+      const result = await analyzeStakingOperation(mockAddress, mockTx);
+
+      expect(result).toBeNull();
+    });
+
+    it("returns null when staked node doesn't change", async () => {
+      const accountBefore = getMockedMirrorAccount({ staked_node_id: 5 });
+      const accountAfter = getMockedMirrorAccount({ staked_node_id: 5 });
+
+      (apiClient.getAccount as jest.Mock)
+        .mockResolvedValueOnce(accountBefore)
+        .mockResolvedValueOnce(accountAfter);
+
+      const result = await analyzeStakingOperation(mockAddress, mockTx);
+
+      expect(result).toBeNull();
+    });
+  });
 });

package/src/logic/utils.ts

@@ -15,21 +15,24 @@ import { InvalidAddress } from "@ledgerhq/errors";
 import { getEnv } from "@ledgerhq/live-env";
 import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
 import type { Currency, ExplorerView, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import type { AccountLike, Operation as LiveOperation } from "@ledgerhq/types-live";
+import type { AccountLike, Operation as LiveOperation, OperationType } from "@ledgerhq/types-live";
 import {
   HEDERA_DELEGATION_STATUS,
   HEDERA_OPERATION_TYPES,
   HEDERA_TRANSACTION_MODES,
   SYNTHETIC_BLOCK_WINDOW_SECONDS,
+  TINYBAR_SCALE,
 } from "../constants";
 import { apiClient } from "../network/api";
 import type {
   HederaAccount,
   HederaMemo,
+  HederaMirrorTransaction,
   HederaOperationExtra,
   HederaTxData,
   HederaValidator,
   OperationDetailsExtraField,
+  StakingAnalysis,
   Transaction,
   TransactionStaking,
   TransactionStatus,
@@ -493,3 +496,66 @@ export const hasSpecificIntentData = <Type extends "staking" | "erc20">(
 ): txIntent is Extract<TransactionIntent<HederaMemo, HederaTxData>, { data: { type: Type } }> => {
   return "data" in txIntent && txIntent.data.type === expectedType;
 };
+
+export const calculateAPY = (rewardRateStart: number): number => {
+  const dailyRate = rewardRateStart / 10 ** TINYBAR_SCALE;
+  const annualRate = dailyRate * 365;
+
+  return annualRate;
+};
+
+/**
+ * Hedera uses the AccountUpdateTransaction for multiple purposes, including staking operations.
+ * Mirror node classifies all such transactions under the same name: "CRYPTOUPDATEACCOUNT".
+ *
+ * This function distinguishes between:
+ * - DELEGATE: Account started staking (staked_node_id changed from null to a node ID)
+ * - UNDELEGATE: Account stopped staking (staked_node_id changed from a node ID to null)
+ * - REDELEGATE: Account changed staking node (staked_node_id changed from one node to another)
+ *
+ * The analysis works by:
+ * 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
+ */
+export const analyzeStakingOperation = async (
+  address: string,
+  mirrorTx: HederaMirrorTransaction,
+): Promise<StakingAnalysis | null> => {
+  const [accountBefore, accountAfter] = await Promise.all([
+    apiClient.getAccount(address, `lt:${mirrorTx.consensus_timestamp}`),
+    apiClient.getAccount(address, `eq:${mirrorTx.consensus_timestamp}`),
+  ]);
+
+  let operationType: OperationType | null = null;
+  const previousStakingNodeId = accountBefore.staked_node_id;
+  const targetStakingNodeId = accountAfter.staked_node_id;
+
+  // stake: node id changed from null -> not null
+  if (previousStakingNodeId === null && targetStakingNodeId !== null) {
+    operationType = "DELEGATE";
+  }
+  // unstake: node id changed from not null -> null
+  else if (previousStakingNodeId !== null && targetStakingNodeId === null) {
+    operationType = "UNDELEGATE";
+  }
+  // restake: node id changed from not null -> different not null
+  else if (
+    previousStakingNodeId !== null &&
+    targetStakingNodeId !== null &&
+    previousStakingNodeId !== targetStakingNodeId
+  ) {
+    operationType = "REDELEGATE";
+  }
+
+  if (!operationType) {
+    return null;
+  }
+
+  return {
+    operationType,
+    previousStakingNodeId,
+    targetStakingNodeId,
+    stakedAmount: BigInt(accountAfter.balance.balance), // always entire balance on Hedera (fully liquid)
+  };
+};

package/src/network/api.test.ts

@@ -124,6 +124,8 @@ describe("getAccountTransactions", () => {
 });
 
 describe("getAccount", () => {
+  const mockAddress = "0.0.1234";
+
   beforeEach(() => {
     jest.resetAllMocks();
   });
@@ -131,7 +133,7 @@ describe("getAccount", () => {
   it("should call the correct endpoint and return account data", async () => {
     mockedNetwork.mockResolvedValueOnce(
       getMockResponse({
-        account: "0.0.1234",
+        account: mockAddress,
         max_automatic_token_associations: 0,
         balance: {
           balance: 1000,
@@ -141,13 +143,29 @@ describe("getAccount", () => {
       }),
     );
 
-    const result = await apiClient.getAccount("0.0.1234");
+    const result = await apiClient.getAccount(mockAddress);
     const requestUrl = mockedNetwork.mock.calls[0][0].url;
 
-    expect(result.account).toEqual("0.0.1234");
-    expect(requestUrl).toContain("/api/v1/accounts/0.0.1234");
+    expect(result.account).toEqual(mockAddress);
+    expect(requestUrl).toContain(`/api/v1/accounts/${mockAddress}?transactions=false`);
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
   });
+
+  it("supports timestamp filter", async () => {
+    const mockAccount = { account: mockAddress, staked_node_id: null };
+    const timestamp = "lt:1762202064.065172388";
+
+    (network as jest.Mock).mockResolvedValueOnce({ data: mockAccount });
+
+    const result = await apiClient.getAccount(mockAddress, timestamp);
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(mockAccount);
+    expect(requestUrl).toContain(
+      `/api/v1/accounts/${mockAddress}?transactions=false&timestamp=${encodeURIComponent(timestamp)}`,
+    );
+  });
 });
 
 describe("getAccountTokens", () => {
@@ -536,17 +554,17 @@ describe("getNodes", () => {
       }),
     );
 
-    const result = await apiClient.getNodes();
+    const result = await apiClient.getNodes({ fetchAllPages: true });
     const requestUrl = mockedNetwork.mock.calls[0][0].url;
 
-    expect(result.map(n => n.node_id)).toEqual([0, 1]);
+    expect(result.nodes.map(n => n.node_id)).toEqual([0, 1]);
     expect(requestUrl).toContain("/api/v1/network/nodes");
     expect(requestUrl).toContain("limit=100");
     expect(requestUrl).toContain("order=desc");
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
   });
 
-  it("should keep fetching if links.next is present and new nodes are returned", async () => {
+  it("should keep fetching if fetchAllPages and links.next is present", async () => {
     mockedNetwork
       .mockResolvedValueOnce(
         getMockResponse({
@@ -567,9 +585,37 @@ describe("getNodes", () => {
         }),
       );
 
-    const result = await apiClient.getNodes();
+    const result = await apiClient.getNodes({ fetchAllPages: true });
 
-    expect(result.map(n => n.node_id)).toEqual([0, 1, 2]);
+    expect(result.nodes.map(n => n.node_id)).toEqual([0, 1, 2]);
     expect(mockedNetwork).toHaveBeenCalledTimes(3);
   });
+
+  it("should paginate if fetchAllPages is not set", async () => {
+    mockedNetwork
+      .mockResolvedValueOnce(
+        getMockResponse({
+          nodes: [
+            { node_id: 0, node_account_id: "0.0.3" },
+            { node_id: 1, node_account_id: "0.0.4" },
+          ],
+          links: { next: "/next-1" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          nodes: [{ node_id: 2, node_account_id: "0.0.5" }],
+          links: { next: null },
+        }),
+      );
+
+    const result = await apiClient.getNodes({
+      limit: 2,
+      fetchAllPages: false,
+    });
+
+    expect(result.nodes.map(tx => tx.node_id)).toEqual([0, 1]);
+    expect(result.nextCursor).toBe("1");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
 });

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;
+}