@ledgerhq/coin-hedera 1.15.0 → 1.16.0-nightly.20251210114107

package/src/bridge/serialization.ts

@@ -1,3 +1,4 @@
+import BigNumber from "bignumber.js";
 import type { AccountRaw, Account } from "@ledgerhq/types-live";
 import type {
   HederaAccount,
@@ -8,19 +9,35 @@ import type {
 
 export function toHederaResourcesRaw(resources: HederaResources): HederaResourcesRaw {
   const { maxAutomaticTokenAssociations, isAutoTokenAssociationEnabled } = resources;
+  const delegation = resources.delegation
+    ? {
+        nodeId: resources.delegation.nodeId,
+        delegated: resources.delegation.delegated.toString(),
+        pendingReward: resources.delegation.pendingReward.toString(),
+      }
+    : null;
 
   return {
     maxAutomaticTokenAssociations,
     isAutoTokenAssociationEnabled,
+    delegation,
   };
 }
 
 export function fromHederaResourcesRaw(rawResources: HederaResourcesRaw): HederaResources {
   const { maxAutomaticTokenAssociations, isAutoTokenAssociationEnabled } = rawResources;
+  const delegation = rawResources.delegation
+    ? {
+        nodeId: rawResources.delegation.nodeId,
+        delegated: new BigNumber(rawResources.delegation.delegated),
+        pendingReward: new BigNumber(rawResources.delegation.pendingReward),
+      }
+    : null;
 
   return {
     maxAutomaticTokenAssociations,
     isAutoTokenAssociationEnabled,
+    delegation,
   };
 }
 

package/src/bridge/signOperation.ts

@@ -1,7 +1,7 @@
 import { Observable } from "rxjs";
-import { Account, AccountBridge } from "@ledgerhq/types-live";
-import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import type { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
+import type { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 import { buildOptimisticOperation } from "./buildOptimisticOperation";
 import { DEFAULT_GAS_LIMIT, HEDERA_TRANSACTION_MODES } from "../constants";
@@ -12,13 +12,14 @@ import {
   serializeTransaction,
   getHederaTransactionBodyBytes,
   isTokenAssociateTransaction,
+  isStakingTransaction,
 } from "../logic/utils";
-import type { Transaction, HederaSigner, HederaTxData } from "../types";
+import type { Transaction, HederaSigner, HederaTxData, HederaAccount } from "../types";
 
 export const buildSignOperation =
   (
     signerContext: SignerContext<HederaSigner>,
-  ): AccountBridge<Transaction, Account>["signOperation"] =>
+  ): AccountBridge<Transaction, HederaAccount>["signOperation"] =>
   ({ account, transaction, deviceId }) =>
     new Observable(o => {
       void (async function () {
@@ -64,6 +65,15 @@ export const buildSignOperation =
               type: "erc20",
               gasLimit: BigInt((transaction.gasLimit ?? DEFAULT_GAS_LIMIT).toString()),
             };
+          } else if (isStakingTransaction(transaction)) {
+            type = transaction.mode;
+            asset = {
+              type: "native",
+            };
+            data = {
+              type: "staking",
+              stakingNodeId: transaction.properties?.stakingNodeId,
+            };
           } else {
             type = HEDERA_TRANSACTION_MODES.Send;
             asset = {

package/src/bridge/synchronisation.ts

@@ -107,6 +107,14 @@ export const getAccountShape: GetAccountShape<HederaAccount> = async (
   const operations = shouldSyncFromScratch
     ? enrichedNewOperations
     : mergeOps(oldOperations, enrichedNewOperations);
+  const delegation =
+    typeof mirrorAccount.staked_node_id === "number"
+      ? {
+          nodeId: mirrorAccount.staked_node_id,
+          delegated: accountBalance,
+          pendingReward: new BigNumber(mirrorAccount.pending_reward),
+        }
+      : null;
 
   // how ERC20 operations are handled:
   // - mirror node doesn't include "IN" erc20 token transactions
@@ -159,6 +167,7 @@ export const getAccountShape: GetAccountShape<HederaAccount> = async (
     hederaResources: {
       maxAutomaticTokenAssociations: mirrorAccount.max_automatic_token_associations,
       isAutoTokenAssociationEnabled: mirrorAccount.max_automatic_token_associations === -1,
+      delegation,
     },
   };
 };

package/src/bridge/utils.integration.test.ts

@@ -218,7 +218,7 @@ describe("utils", () => {
         erc20Tokens: [],
       });
 
-      expect(result).toHaveLength(0);
+      expect(result).toEqual([]);
     });
 
     it("returns sub account for mirror token with no operations yet (e.g. right after association)", async () => {
@@ -237,7 +237,6 @@ describe("utils", () => {
         erc20Tokens: [],
       });
 
-      expect(result).toHaveLength(1);
       expect(result).toMatchObject([
         {
           token: tokenCurrencyFromCAL,
@@ -259,7 +258,6 @@ describe("utils", () => {
         erc20Tokens: [{ balance: new BigNumber(42), token: tokenCurrencyFromCAL }],
       });
 
-      expect(result).toHaveLength(1);
       expect(result).toMatchObject([
         {
           token: tokenCurrencyFromCAL,
@@ -341,7 +339,6 @@ describe("utils", () => {
         hash: incomingTxHash,
         blockHash: incomingERC20Transaction.blockHash,
       });
-      expect(incomingOp?.subOperations).toHaveLength(1);
       expect(incomingOp?.subOperations).toMatchObject([
         {
           type: "IN",
@@ -353,7 +350,6 @@ describe("utils", () => {
           recipients: [address],
         },
       ]);
-      expect(newERC20TokenOperations).toHaveLength(1);
       expect(newERC20TokenOperations).toMatchObject([incomingOp?.subOperations?.[0]]);
       expect(updatedOperations).toHaveLength(oldMirrorOperations.length + 1);
     });
@@ -422,7 +418,6 @@ describe("utils", () => {
         blockHash: allowanceERC20Transaction.blockHash,
         standard: "erc20",
       });
-      expect(allowanceOp?.subOperations).toHaveLength(1);
       expect(allowanceOp?.subOperations).toMatchObject([
         {
           type: "OUT",
@@ -434,7 +429,6 @@ describe("utils", () => {
           recipients: [allowanceTxTo],
         },
       ]);
-      expect(newERC20TokenOperations).toHaveLength(1);
       expect(newERC20TokenOperations).toMatchObject([allowanceOp?.subOperations?.[0]]);
       expect(updatedOperations).toHaveLength(oldMirrorOperations.length + 1);
     });
@@ -519,7 +513,7 @@ describe("utils", () => {
       );
 
       expect(updatedOperations).toHaveLength(2);
-      expect(duplicatedContractCalls).toHaveLength(0);
+      expect(duplicatedContractCalls).toEqual([]);
       expect(feesOps).toHaveLength(1);
       expect(feesOps).toMatchObject([{ blockHash: "0xBLOCK" }]);
     });
@@ -553,7 +547,7 @@ describe("utils", () => {
 
       expect(pendingOp).toBeUndefined();
       expect(updatedOperations).toHaveLength(1);
-      expect(updatedOperations[0].hash).toBe("confirmed_tx");
+      expect(updatedOperations).toMatchObject([{ hash: "confirmed_tx" }]);
     });
 
     /**
@@ -672,7 +666,6 @@ describe("utils", () => {
           },
         ],
       });
-      expect(newERC20TokenOperations).toHaveLength(1);
       expect(newERC20TokenOperations).toMatchObject([
         {
           type: "OUT",

package/src/constants.ts

@@ -7,12 +7,17 @@ import BigNumber from "bignumber.js";
 export enum HEDERA_TRANSACTION_MODES {
   Send = "send",
   TokenAssociate = "token-associate",
+  Delegate = "delegate",
+  Undelegate = "undelegate",
+  Redelegate = "redelegate",
+  ClaimRewards = "claim-rewards",
 }
 
 /**
  * Enum representing the supported Hedera operation types for fee estimation
  */
 export enum HEDERA_OPERATION_TYPES {
+  CryptoUpdate = "CryptoUpdate",
   CryptoTransfer = "CryptoTransfer",
   TokenTransfer = "TokenTransfer",
   TokenAssociate = "TokenAssociate",
@@ -39,6 +44,15 @@ export const DEFAULT_GAS_PRICE_TINYBARS = new BigNumber(100);
 
 export const HEDERA_MAINNET_CHAIN_ID = 295;
 
+/**
+ * Enum representing the delegation status of a Hedera account
+ */
+export enum HEDERA_DELEGATION_STATUS {
+  Inactive = "inactive",
+  Overstaked = "overstaked",
+  Active = "active",
+}
+
 /**
  * https://docs.hedera.com/hedera/networks/mainnet/fees
  *
@@ -49,6 +63,7 @@ export const HEDERA_MAINNET_CHAIN_ID = 295;
  * has sufficient balance to cover the cost of a transaction (e.g. token association).
  */
 export const BASE_USD_FEE_BY_OPERATION_TYPE = {
+  [HEDERA_OPERATION_TYPES.CryptoUpdate]: 0.00022 * 10 ** TINYBAR_SCALE,
   [HEDERA_OPERATION_TYPES.CryptoTransfer]: 0.0001 * 10 ** TINYBAR_SCALE,
   [HEDERA_OPERATION_TYPES.TokenTransfer]: 0.001 * 10 ** TINYBAR_SCALE,
   [HEDERA_OPERATION_TYPES.TokenAssociate]: 0.05 * 10 ** TINYBAR_SCALE,
@@ -84,3 +99,10 @@ export const SUPPORTED_ERC20_TOKENS = [
     tokenId: "0.0.10047837",
   },
 ];
+
+export const MAP_STAKING_MODE_TO_MEMO = {
+  [HEDERA_TRANSACTION_MODES.ClaimRewards]: "Collect Staking Rewards",
+  [HEDERA_TRANSACTION_MODES.Delegate]: "Stake",
+  [HEDERA_TRANSACTION_MODES.Undelegate]: "Unstake",
+  [HEDERA_TRANSACTION_MODES.Redelegate]: "Restake",
+} as const;

package/src/deviceTransactionConfig.test.ts

@@ -0,0 +1,315 @@
+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";
+
+describe("getDeviceTransactionConfig", () => {
+  const mockAccount = {
+    id: "mock-account-id",
+    currency: { id: "hedera" },
+  } as Account;
+
+  const createMockStatus = (estimatedFees: BigNumber): TransactionStatus => ({
+    errors: {},
+    warnings: {},
+    estimatedFees,
+    amount: new BigNumber(0),
+    totalSpent: new BigNumber(0),
+  });
+
+  describe("staking transactions", () => {
+    it("should return correct fields for ClaimRewards transaction", async () => {
+      const transaction = {
+        family: "hedera",
+        mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
+        amount: new BigNumber(0),
+        recipient: "",
+        memo: "Claiming rewards",
+      } as Transaction;
+
+      const status = createMockStatus(new BigNumber(100000));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Claim Rewards",
+        },
+        {
+          label: "Fees",
+          type: "fees",
+        },
+        {
+          type: "text",
+          label: "Memo",
+          value: "Claiming rewards",
+        },
+      ]);
+    });
+
+    it("should return correct fields for Delegate transaction", async () => {
+      const transaction = {
+        family: "hedera",
+        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: "Update Account",
+        },
+        {
+          label: "Fees",
+          type: "fees",
+        },
+        {
+          type: "text",
+          label: "Staked Node ID",
+          value: "10",
+        },
+      ]);
+    });
+
+    it("should not include staking node ID if not provided", async () => {
+      const transaction = {
+        family: "hedera",
+        mode: HEDERA_TRANSACTION_MODES.Undelegate,
+        amount: new BigNumber(0),
+        recipient: "",
+        properties: {},
+      } as Transaction;
+
+      const status = createMockStatus(new BigNumber(100000));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Update Account",
+        },
+        {
+          label: "Fees",
+          type: "fees",
+        },
+      ]);
+    });
+  });
+
+  describe("token associate transactions", () => {
+    it("should return correct fields for TokenAssociate transaction", async () => {
+      const transaction = {
+        family: "hedera",
+        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));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Associate Token",
+        },
+        {
+          type: "fees",
+          label: "Fees",
+        },
+        {
+          type: "text",
+          label: "Memo",
+          value: "Associating token",
+        },
+      ]);
+    });
+
+    it("should not include fees if they are zero", async () => {
+      const transaction = {
+        family: "hedera",
+        mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
+        amount: new BigNumber(0),
+        recipient: "",
+        subAccountId: "token-account-id",
+      } as Transaction;
+
+      const status = createMockStatus(new BigNumber(0));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Associate Token",
+        },
+      ]);
+    });
+  });
+
+  describe("regular transfer transactions", () => {
+    it("should return correct fields for regular Send transaction", async () => {
+      const transaction = {
+        family: "hedera",
+        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));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Transfer",
+        },
+        {
+          type: "amount",
+          label: "Amount",
+        },
+        {
+          type: "fees",
+          label: "Fees",
+        },
+        {
+          type: "text",
+          label: "Memo",
+          value: "Payment",
+        },
+      ]);
+    });
+
+    it("should show 'Transfer All' method when useAllAmount is true", async () => {
+      const transaction = {
+        family: "hedera",
+        mode: HEDERA_TRANSACTION_MODES.Send,
+        amount: new BigNumber(0),
+        recipient: "0.0.12345",
+        useAllAmount: true,
+      } as Transaction;
+
+      const status = createMockStatus(new BigNumber(100000));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields[0]).toEqual({
+        type: "text",
+        label: "Method",
+        value: "Transfer All",
+      });
+    });
+
+    it("should include gas limit for Send transactions with gasLimit", async () => {
+      const transaction = {
+        family: "hedera",
+        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));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Transfer",
+        },
+        {
+          type: "amount",
+          label: "Amount",
+        },
+        {
+          type: "fees",
+          label: "Fees",
+        },
+        {
+          type: "text",
+          label: "Gas Limit",
+          value: "300000",
+        },
+      ]);
+    });
+
+    it("should not include memo if not provided", async () => {
+      const transaction = {
+        family: "hedera",
+        mode: HEDERA_TRANSACTION_MODES.Send,
+        amount: new BigNumber(1000000),
+        recipient: "0.0.12345",
+        useAllAmount: false,
+      } as Transaction;
+
+      const status = createMockStatus(new BigNumber(100000));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toHaveLength(3);
+      expect(fields.some(f => f.label === "Memo")).toBe(false);
+    });
+  });
+});

package/src/deviceTransactionConfig.ts

@@ -1,7 +1,7 @@
 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 { isTokenAssociateTransaction } from "./logic/utils";
+import { isTokenAssociateTransaction, isStakingTransaction } from "./logic/utils";
 import type { Transaction, TransactionStatus } from "./types";
 
 async function getDeviceTransactionConfig({
@@ -15,6 +15,42 @@ async function getDeviceTransactionConfig({
 }): Promise<Array<DeviceTransactionField>> {
   const fields: Array<DeviceTransactionField> = [];
 
+  if (isStakingTransaction(transaction)) {
+    fields.push({
+      type: "text",
+      label: "Method",
+      value:
+        transaction.mode === HEDERA_TRANSACTION_MODES.ClaimRewards
+          ? "Claim Rewards"
+          : "Update Account",
+    });
+
+    if (!estimatedFees.isZero()) {
+      fields.push({
+        type: "fees",
+        label: "Fees",
+      });
+    }
+
+    if (typeof transaction.properties?.stakingNodeId === "number") {
+      fields.push({
+        type: "text",
+        label: "Staked Node ID",
+        value: transaction.properties.stakingNodeId.toString(),
+      });
+    }
+
+    if (transaction.memo) {
+      fields.push({
+        type: "text",
+        label: "Memo",
+        value: transaction.memo,
+      });
+    }
+
+    return fields;
+  }
+
   const method = (() => {
     if (isTokenAssociateTransaction(transaction)) return "Associate Token";
     else if (transaction.useAllAmount) return "Transfer All";

package/src/errors.ts

@@ -16,3 +16,10 @@ export const HederaRecipientTokenAssociationUnverified = createCustomErrorClass(
 export const HederaRecipientEvmAddressVerificationRequired = createCustomErrorClass(
   "HederaRecipientEvmAddressVerificationRequired",
 );
+export const HederaRedundantStakingNodeIdError = createCustomErrorClass(
+  "HederaRedundantStakingNodeIdError",
+);
+export const HederaInvalidStakingNodeIdError = createCustomErrorClass(
+  "HederaInvalidStakingNodeIdError",
+);
+export const HederaNoStakingRewardsError = createCustomErrorClass("HederaNoStakingRewardsError");