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

package/src/deviceTransactionConfig.test.ts

@@ -1,14 +1,12 @@
 import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
 import { HEDERA_TRANSACTION_MODES } from "./constants";
 import getDeviceTransactionConfig from "./deviceTransactionConfig";
-import type { Transaction, TransactionStatus } from "./types";
+import type { TransactionStatus } from "./types";
+import { getMockedAccount } from "./test/fixtures/account.fixture";
+import { getMockedTransaction } from "./test/fixtures/transaction.fixture";
 
 describe("getDeviceTransactionConfig", () => {
-  const mockAccount = {
-    id: "mock-account-id",
-    currency: { id: "hedera" },
-  } as Account;
+  const mockAccount = getMockedAccount({ id: "mock-account-id" });
 
   const createMockStatus = (estimatedFees: BigNumber): TransactionStatus => ({
     errors: {},
@@ -20,13 +18,11 @@ describe("getDeviceTransactionConfig", () => {
 
   describe("staking transactions", () => {
     it("should return correct fields for ClaimRewards transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
         amount: new BigNumber(0),
-        recipient: "",
         memo: "Claiming rewards",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -55,15 +51,48 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should return correct fields for Delegate transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Delegate,
         amount: new BigNumber(0),
-        recipient: "",
         properties: {
           stakingNodeId: 10,
         },
-      } as Transaction;
+      });
+
+      const status = createMockStatus(new BigNumber(100000));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Delegate",
+        },
+        {
+          label: "Fees",
+          type: "fees",
+        },
+        {
+          type: "text",
+          label: "Staked Node ID",
+          value: "10",
+        },
+      ]);
+    });
+
+    it("should return correct fields for Redelegate transaction", async () => {
+      const transaction = getMockedTransaction({
+        mode: HEDERA_TRANSACTION_MODES.Redelegate,
+        amount: new BigNumber(0),
+        properties: {
+          stakingNodeId: 10,
+        },
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -77,7 +106,7 @@ describe("getDeviceTransactionConfig", () => {
         {
           type: "text",
           label: "Method",
-          value: "Update Account",
+          value: "Redelegate",
         },
         {
           label: "Fees",
@@ -92,13 +121,10 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should not include staking node ID if not provided", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Undelegate,
         amount: new BigNumber(0),
-        recipient: "",
-        properties: {},
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -112,7 +138,7 @@ describe("getDeviceTransactionConfig", () => {
         {
           type: "text",
           label: "Method",
-          value: "Update Account",
+          value: "Undelegate",
         },
         {
           label: "Fees",
@@ -124,14 +150,11 @@ describe("getDeviceTransactionConfig", () => {
 
   describe("token associate transactions", () => {
     it("should return correct fields for TokenAssociate transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
-        amount: new BigNumber(0),
-        recipient: "",
         subAccountId: "token-account-id",
         memo: "Associating token",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(50000));
 
@@ -160,13 +183,10 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should not include fees if they are zero", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
-        amount: new BigNumber(0),
-        recipient: "",
         subAccountId: "token-account-id",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(0));
 
@@ -188,14 +208,13 @@ describe("getDeviceTransactionConfig", () => {
 
   describe("regular transfer transactions", () => {
     it("should return correct fields for regular Send transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(1000000),
         recipient: "0.0.12345",
         useAllAmount: false,
         memo: "Payment",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -228,13 +247,12 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should show 'Transfer All' method when useAllAmount is true", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(0),
         recipient: "0.0.12345",
         useAllAmount: true,
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -252,14 +270,13 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should include gas limit for Send transactions with gasLimit", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(1000000),
         recipient: "0.0.12345",
         useAllAmount: false,
         gasLimit: new BigNumber(300000),
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -292,13 +309,12 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should not include memo if not provided", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(1000000),
         recipient: "0.0.12345",
         useAllAmount: false,
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 

package/src/deviceTransactionConfig.ts

@@ -1,6 +1,6 @@
 import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
 import type { AccountLike, Account } from "@ledgerhq/types-live";
-import { HEDERA_TRANSACTION_MODES } from "./constants";
+import { HEDERA_TRANSACTION_MODES, MAP_STAKING_MODE_TO_METHOD } from "./constants";
 import { isTokenAssociateTransaction, isStakingTransaction } from "./logic/utils";
 import type { Transaction, TransactionStatus } from "./types";
 
@@ -19,10 +19,7 @@ async function getDeviceTransactionConfig({
     fields.push({
       type: "text",
       label: "Method",
-      value:
-        transaction.mode === HEDERA_TRANSACTION_MODES.ClaimRewards
-          ? "Claim Rewards"
-          : "Update Account",
+      value: MAP_STAKING_MODE_TO_METHOD[transaction.mode],
     });
 
     if (!estimatedFees.isZero()) {

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),
+      },
+    ]);
+  });
 });