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

package/src/logic/getBalance.test.ts

@@ -22,6 +22,7 @@ describe("getBalance", () => {
 
     (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
     (apiClient.getAccountTokens as jest.Mock).mockResolvedValue([]);
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({ nodes: [] });
 
     const result = await getBalance(mockCurrency, address);
 
@@ -70,6 +71,7 @@ describe("getBalance", () => {
 
     (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
     (apiClient.getAccountTokens as jest.Mock).mockResolvedValue(mockMirrorTokens);
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({ nodes: [] });
 
     const result = await getBalance(mockCurrency, address);
 
@@ -99,6 +101,51 @@ describe("getBalance", () => {
     );
   });
 
+  it("should return stake", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const mockMirrorAccount = {
+      account: address,
+      staked_node_id: 5,
+      balance: {
+        balance: 100,
+      },
+      pending_reward: 100,
+    };
+    const mockMirrorNode = {
+      node_id: 5,
+      node_account_id: "0.0.5",
+      description: "Hosted for Wipro | Amsterdam, Netherlands",
+      max_stake: 45000000000000000,
+      stake: 45000000000000000,
+    };
+
+    (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
+    (apiClient.getAccountTokens as jest.Mock).mockResolvedValue([]);
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({ nodes: [mockMirrorNode] });
+
+    const result = await getBalance(mockCurrency, address);
+
+    expect(apiClient.getAccount).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccount).toHaveBeenCalledWith(address);
+    expect(apiClient.getNodes).toHaveBeenCalledTimes(1);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      asset: { type: "native" },
+      value: BigInt(mockMirrorAccount.balance.balance),
+      stake: {
+        uid: address,
+        address,
+        asset: { type: "native" },
+        state: "active",
+        amount: BigInt(mockMirrorAccount.balance.balance + mockMirrorAccount.pending_reward),
+        amountDeposited: BigInt(mockMirrorAccount.balance.balance),
+        amountRewarded: BigInt(mockMirrorAccount.pending_reward),
+        delegate: mockMirrorNode.node_account_id,
+      },
+    });
+  });
+
   it("should skip tokens not found in CAL", async () => {
     const address = "0.0.12345";
     const mockCurrency = getMockedCurrency();
@@ -145,6 +192,7 @@ describe("getBalance", () => {
 
     (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
     (apiClient.getAccountTokens as jest.Mock).mockResolvedValue(mockMirrorTokens);
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({ nodes: [] });
 
     const result = await getBalance(mockCurrency, address);
 
@@ -173,6 +221,7 @@ describe("getBalance", () => {
 
     (apiClient.getAccount as jest.Mock).mockRejectedValue(error);
     (apiClient.getAccountTokens as jest.Mock).mockResolvedValue([]);
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({ nodes: [] });
 
     await expect(getBalance(mockCurrency, address)).rejects.toThrow(error);
   });
@@ -189,6 +238,7 @@ describe("getBalance", () => {
 
     (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
     (apiClient.getAccountTokens as jest.Mock).mockRejectedValue(error);
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({ nodes: [] });
 
     await expect(getBalance(mockCurrency, address)).rejects.toThrow(error);
   });

package/src/logic/getBalance.ts

@@ -4,15 +4,32 @@ import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import { apiClient } from "../network/api";
 
 export async function getBalance(currency: CryptoCurrency, address: string): Promise<Balance[]> {
-  const [mirrorAccount, mirrorTokens] = await Promise.all([
+  const [mirrorAccount, mirrorTokens, mirrorNodes] = await Promise.all([
     apiClient.getAccount(address),
     apiClient.getAccountTokens(address),
+    apiClient.getNodes({ fetchAllPages: true }),
   ]);
 
-  const balance: Balance[] = [
+  const validator = mirrorNodes.nodes.find(v => v.node_id === mirrorAccount.staked_node_id);
+  const balances: Balance[] = [
     {
       asset: { type: "native" },
       value: BigInt(mirrorAccount.balance.balance),
+      ...(validator && {
+        stake: {
+          uid: address,
+          address,
+          asset: { type: "native" },
+          state: "active",
+          amount: BigInt(mirrorAccount.balance.balance) + BigInt(mirrorAccount.pending_reward),
+          amountDeposited: BigInt(mirrorAccount.balance.balance),
+          amountRewarded: BigInt(mirrorAccount.pending_reward),
+          delegate: validator.node_account_id,
+          details: {
+            overstaked: BigInt(validator.stake) >= BigInt(validator.max_stake),
+          },
+        },
+      }),
     },
   ];
 
@@ -26,7 +43,7 @@ export async function getBalance(currency: CryptoCurrency, address: string): Pro
       continue;
     }
 
-    balance.push({
+    balances.push({
       value: BigInt(mirrorToken.balance),
       asset: {
         type: calToken.tokenType,
@@ -38,5 +55,5 @@ export async function getBalance(currency: CryptoCurrency, address: string): Pro
     });
   }
 
-  return balance;
+  return balances;
 }

package/src/logic/getBlock.test.ts

@@ -1,7 +1,9 @@
+import { HEDERA_TRANSACTION_NAMES } from "../constants";
 import { getBlock } from "./getBlock";
 import { getBlockInfo } from "./getBlockInfo";
 import { apiClient } from "../network/api";
-import { getTimestampRangeFromBlockHeight } from "./utils";
+import type { StakingAnalysis } from "../types";
+import { analyzeStakingOperation, getTimestampRangeFromBlockHeight } from "./utils";
 
 jest.mock("./getBlockInfo");
 jest.mock("../network/api");
@@ -23,6 +25,7 @@ describe("getBlock", () => {
     jest.clearAllMocks();
     (getBlockInfo as jest.Mock).mockResolvedValue(mockBlockInfo);
     (getTimestampRangeFromBlockHeight as jest.Mock).mockReturnValue(mockTimestampRange);
+    (analyzeStakingOperation as jest.Mock).mockResolvedValue(null);
   });
 
   it("should return empty block when no transactions exist", async () => {
@@ -57,6 +60,7 @@ describe("getBlock", () => {
       name: "CRYPTOTRANSFER",
       result: "SUCCESS",
       charged_tx_fee: 100000,
+      staking_reward_transfers: [],
       transfers: [],
       token_transfers: [],
     };
@@ -75,6 +79,7 @@ describe("getBlock", () => {
       name: "CRYPTOTRANSFER",
       result: "SUCCESS",
       charged_tx_fee: 67179,
+      staking_reward_transfers: [],
       transfers: [
         {
           account: "0.0.999",
@@ -98,4 +103,281 @@ describe("getBlock", () => {
       amount: BigInt(-567179 + 67179),
     });
   });
+
+  it("should handle token transfers", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash",
+      name: "CRYPTOTRANSFER",
+      result: "SUCCESS",
+      charged_tx_fee: 100000,
+      staking_reward_transfers: [],
+      transfers: [],
+      token_transfers: [
+        {
+          token_id: "0.0.12345",
+          account: "0.0.999",
+          amount: -1000,
+        },
+        {
+          token_id: "0.0.12345",
+          account: "0.0.1001",
+          amount: 1000,
+        },
+      ],
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+
+    const result = await getBlock(100);
+
+    expect(result.transactions[0].operations).toEqual([
+      {
+        type: "transfer",
+        address: "0.0.999",
+        asset: {
+          type: "hts",
+          assetReference: "0.0.12345",
+        },
+        amount: BigInt(-1000),
+      },
+      {
+        type: "transfer",
+        address: "0.0.1001",
+        asset: {
+          type: "hts",
+          assetReference: "0.0.12345",
+        },
+        amount: BigInt(1000),
+      },
+    ]);
+  });
+
+  it("should mark failed transactions", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash",
+      name: "CRYPTOTRANSFER",
+      result: "INSUFFICIENT_ACCOUNT_BALANCE",
+      charged_tx_fee: 100000,
+      staking_reward_transfers: [],
+      transfers: [],
+      token_transfers: [],
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+
+    const result = await getBlock(100);
+
+    expect(result.transactions[0].failed).toBe(true);
+  });
+
+  it("should analyze CRYPTOUPDATEACCOUNT transactions for staking", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash_update",
+      name: HEDERA_TRANSACTION_NAMES.UpdateAccount,
+      result: "SUCCESS",
+      charged_tx_fee: 22000,
+      consensus_timestamp: "1704067210.123456789",
+      staking_reward_transfers: [],
+      transfers: [],
+      token_transfers: [],
+    };
+    const mockStakingAnalysis: StakingAnalysis = {
+      operationType: "DELEGATE",
+      targetStakingNodeId: 5,
+      previousStakingNodeId: null,
+      stakedAmount: BigInt(100),
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+    (analyzeStakingOperation as jest.Mock).mockResolvedValue(mockStakingAnalysis);
+
+    const result = await getBlock(100);
+
+    expect(analyzeStakingOperation).toHaveBeenCalledTimes(1);
+    expect(analyzeStakingOperation).toHaveBeenCalledWith("0.0.999", mockTx);
+    expect(result.transactions[0].operations).toHaveLength(1);
+    expect(result.transactions[0].operations[0]).toEqual({
+      type: "other",
+      operationType: mockStakingAnalysis.operationType,
+      stakedNodeId: mockStakingAnalysis.targetStakingNodeId,
+      previousStakedNodeId: mockStakingAnalysis.previousStakingNodeId,
+      stakedAmount: mockStakingAnalysis.stakedAmount,
+    });
+  });
+
+  it("should handle UNDELEGATE staking operation", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash_undelegate",
+      name: HEDERA_TRANSACTION_NAMES.UpdateAccount,
+      result: "SUCCESS",
+      charged_tx_fee: 22000,
+      consensus_timestamp: "1704067210.123456789",
+      staking_reward_transfers: [],
+      transfers: [],
+      token_transfers: [],
+    };
+    const mockStakingAnalysis: StakingAnalysis = {
+      operationType: "UNDELEGATE",
+      targetStakingNodeId: null,
+      previousStakingNodeId: 3,
+      stakedAmount: BigInt(100),
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+    (analyzeStakingOperation as jest.Mock).mockResolvedValue(mockStakingAnalysis);
+
+    const result = await getBlock(100);
+
+    expect(result.transactions[0].operations[0]).toEqual({
+      type: "other",
+      operationType: mockStakingAnalysis.operationType,
+      stakedNodeId: mockStakingAnalysis.targetStakingNodeId,
+      previousStakedNodeId: mockStakingAnalysis.previousStakingNodeId,
+      stakedAmount: mockStakingAnalysis.stakedAmount,
+    });
+  });
+
+  it("should handle REDELEGATE staking operation", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash_redelegate",
+      name: HEDERA_TRANSACTION_NAMES.UpdateAccount,
+      result: "SUCCESS",
+      charged_tx_fee: 22000,
+      consensus_timestamp: "1704067210.123456789",
+      staking_reward_transfers: [],
+      transfers: [],
+      token_transfers: [],
+    };
+    const mockStakingAnalysis: StakingAnalysis = {
+      operationType: "REDELEGATE",
+      targetStakingNodeId: 10,
+      previousStakingNodeId: 5,
+      stakedAmount: BigInt(100),
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+    (analyzeStakingOperation as jest.Mock).mockResolvedValue(mockStakingAnalysis);
+
+    const result = await getBlock(100);
+
+    expect(result.transactions[0].operations).toEqual([
+      {
+        type: "other",
+        operationType: mockStakingAnalysis.operationType,
+        stakedNodeId: mockStakingAnalysis.targetStakingNodeId,
+        previousStakedNodeId: mockStakingAnalysis.previousStakingNodeId,
+        stakedAmount: mockStakingAnalysis.stakedAmount,
+      },
+    ]);
+  });
+
+  it("should create CLAIM_REWARDS operations for staking reward transfers", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash",
+      name: "CRYPTOTRANSFER",
+      result: "SUCCESS",
+      charged_tx_fee: 100000,
+      staking_reward_transfers: [
+        {
+          account: "0.0.999",
+          amount: 100000,
+        },
+        {
+          account: "0.0.1001",
+          amount: 200000,
+        },
+      ],
+      transfers: [
+        {
+          account: "0.0.999",
+          amount: -600000,
+        },
+        {
+          account: "0.0.1001",
+          amount: 500000,
+        },
+      ],
+      token_transfers: [],
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+
+    const result = await getBlock(100);
+
+    expect(result.transactions[0].operations).toEqual([
+      {
+        type: "transfer",
+        address: "0.0.999",
+        asset: { type: "native" },
+        amount: BigInt(-500000),
+      },
+      {
+        type: "transfer",
+        address: "0.0.1001",
+        asset: { type: "native" },
+        amount: BigInt(500000),
+      },
+      {
+        type: "transfer",
+        address: "0.0.999",
+        asset: { type: "native" },
+        amount: BigInt(100000),
+      },
+      {
+        type: "transfer",
+        address: "0.0.1001",
+        asset: { type: "native" },
+        amount: BigInt(200000),
+      },
+    ]);
+  });
+
+  it("should handle CRYPTOUPDATEACCOUNT if it's not related to staking", async () => {
+    const mockTx = {
+      transaction_id: "0.0.999-1234567890-000000000",
+      transaction_hash: "hash_regular_update",
+      name: HEDERA_TRANSACTION_NAMES.UpdateAccount,
+      result: "SUCCESS",
+      charged_tx_fee: 22000,
+      consensus_timestamp: "1704067210.123456789",
+      staking_reward_transfers: [],
+      transfers: [
+        {
+          account: "0.0.999",
+          amount: -23000,
+        },
+        {
+          account: "0.0.1000",
+          amount: 1000,
+        },
+      ],
+      token_transfers: [],
+    };
+
+    (apiClient.getTransactionsByTimestampRange as jest.Mock).mockResolvedValue([mockTx]);
+    (analyzeStakingOperation as jest.Mock).mockResolvedValue(null);
+
+    const result = await getBlock(100);
+
+    expect(result.transactions[0].operations).toEqual([
+      {
+        type: "transfer",
+        address: "0.0.999",
+        asset: { type: "native" },
+        amount: BigInt(-1000),
+      },
+      {
+        type: "transfer",
+        address: "0.0.1000",
+        asset: { type: "native" },
+        amount: BigInt(1000),
+      },
+    ]);
+  });
 });

package/src/logic/getBlock.ts

@@ -4,10 +4,19 @@ import type {
   BlockOperation,
   BlockTransaction,
 } from "@ledgerhq/coin-framework/api/types";
+import { HEDERA_TRANSACTION_NAMES } from "../constants";
 import { getBlockInfo } from "./getBlockInfo";
 import { apiClient } from "../network/api";
-import type { HederaMirrorCoinTransfer, HederaMirrorTokenTransfer } from "../types";
-import { getMemoFromBase64, getTimestampRangeFromBlockHeight } from "./utils";
+import type {
+  HederaMirrorCoinTransfer,
+  HederaMirrorTokenTransfer,
+  HederaMirrorTransaction,
+} from "../types";
+import {
+  getMemoFromBase64,
+  analyzeStakingOperation,
+  getTimestampRangeFromBlockHeight,
+} from "./utils";
 
 function toHederaAsset(
   mirrorTransfer: HederaMirrorCoinTransfer | HederaMirrorTokenTransfer,
@@ -45,18 +54,60 @@ function toBlockOperation(
   };
 }
 
+function createStakingRewardOperations(tx: HederaMirrorTransaction): BlockOperation[] {
+  return tx.staking_reward_transfers.map(rewardTransfer => ({
+    type: "transfer",
+    address: rewardTransfer.account,
+    asset: { type: "native" },
+    amount: BigInt(rewardTransfer.amount),
+  }));
+}
+
 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);
 
+  // analyze CRYPTOUPDATEACCOUNT transactions to distinguish staking operations from regular account updates.
+  // this creates a map of transaction_hash -> StakingAnalysis to avoid repeated lookups.
+  const stakingAnalyses = await Promise.all(
+    transactions
+      .filter(tx => tx.name === HEDERA_TRANSACTION_NAMES.UpdateAccount)
+      .map(async tx => {
+        const payerAccount = tx.transaction_id.split("-")[0];
+        const analysis = await analyzeStakingOperation(payerAccount, tx);
+
+        return [tx.transaction_hash, analysis] as const;
+      }),
+  );
+  const stakingAnalysisMap = new Map(stakingAnalyses);
+
   const blockTransactions: BlockTransaction[] = transactions.map(tx => {
     const payerAccount = tx.transaction_id.split("-")[0];
-    const allTransfers = [...tx.transfers, ...tx.token_transfers];
+    const stakingAnalysis = stakingAnalysisMap.get(tx.transaction_hash);
+
+    let operations: BlockOperation[];
+
+    if (stakingAnalysis) {
+      operations = [
+        {
+          type: "other",
+          operationType: stakingAnalysis.operationType,
+          stakedNodeId: stakingAnalysis.targetStakingNodeId,
+          previousStakedNodeId: stakingAnalysis.previousStakingNodeId,
+          stakedAmount: stakingAnalysis.stakedAmount,
+        },
+      ];
+    } else {
+      const allTransfers = [...tx.transfers, ...tx.token_transfers];
+      operations = allTransfers.map(transfer =>
+        toBlockOperation(payerAccount, tx.charged_tx_fee, transfer),
+      );
+    }
 
-    const operations = allTransfers.map(transfer =>
-      toBlockOperation(payerAccount, tx.charged_tx_fee, transfer),
-    );
+    // add staking reward operations if present (can occur on any transaction type)
+    const rewardOperations = createStakingRewardOperations(tx);
+    operations.push(...rewardOperations);
 
     return {
       hash: tx.transaction_hash,

package/src/logic/getValidators.test.ts

@@ -0,0 +1,50 @@
+import { getValidators } from "./getValidators";
+import { apiClient } from "../network/api";
+
+jest.mock("../network/api");
+
+describe("getValidators", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return formatted validators with APY", async () => {
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({
+      nodes: [
+        {
+          node_id: 1,
+          node_account_id: "0.0.3",
+          description: "Hosted by Ledger | Paris, France",
+          stake: 1000000,
+          reward_rate_start: 3538,
+        },
+      ],
+      nextCursor: null,
+    });
+
+    const result = await getValidators();
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]).toMatchObject({
+      address: "0.0.3",
+      nodeId: "1",
+      name: "Ledger",
+      description: "Hosted by Ledger | Paris, France",
+      balance: BigInt(1000000),
+      apy: expect.any(Number),
+    });
+    expect(result.items[0].apy).toBeCloseTo(0.01291, 5);
+  });
+
+  it("should handle pagination cursor", async () => {
+    (apiClient.getNodes as jest.Mock).mockResolvedValue({
+      nodes: [],
+      nextCursor: "123",
+    });
+
+    const result = await getValidators("100");
+
+    expect(apiClient.getNodes).toHaveBeenCalledWith({ cursor: "100", fetchAllPages: false });
+    expect(result.next).toBe("123");
+  });
+});

package/src/logic/getValidators.ts

@@ -0,0 +1,22 @@
+import type { Cursor, Page, Validator } from "@ledgerhq/coin-framework/api/types";
+import { apiClient } from "../network/api";
+import { calculateAPY, extractCompanyFromNodeDescription } from "./utils";
+
+export async function getValidators(cursor?: Cursor): Promise<Page<Validator>> {
+  const res = await apiClient.getNodes({
+    fetchAllPages: false,
+    ...(cursor && { cursor }),
+  });
+
+  return {
+    next: res.nextCursor ?? undefined,
+    items: res.nodes.map(node => ({
+      address: node.node_account_id,
+      nodeId: node.node_id.toString(),
+      name: extractCompanyFromNodeDescription(node.description),
+      description: node.description,
+      balance: BigInt(node.stake),
+      apy: calculateAPY(node.reward_rate_start),
+    })),
+  };
+}

package/src/logic/index.ts

@@ -9,3 +9,4 @@ export { lastBlock } from "./lastBlock";
 export { listOperations } from "./listOperations";
 export { getAssetFromToken } from "./getAssetFromToken";
 export { getTokenFromAsset } from "./getTokenFromAsset";
+export { getValidators } from "./getValidators";