@ledgerhq/coin-hedera 1.15.0-nightly.20251205111238 → 1.15.0

package/src/bridge/serialization.ts

@@ -1,4 +1,3 @@
-import BigNumber from "bignumber.js";
 import type { AccountRaw, Account } from "@ledgerhq/types-live";
 import type {
   HederaAccount,
@@ -9,35 +8,19 @@ 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 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 { Account, AccountBridge } from "@ledgerhq/types-live";
+import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
+import { 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,14 +12,13 @@ import {
   serializeTransaction,
   getHederaTransactionBodyBytes,
   isTokenAssociateTransaction,
-  isStakingTransaction,
 } from "../logic/utils";
-import type { Transaction, HederaSigner, HederaTxData, HederaAccount } from "../types";
+import type { Transaction, HederaSigner, HederaTxData } from "../types";
 
 export const buildSignOperation =
   (
     signerContext: SignerContext<HederaSigner>,
-  ): AccountBridge<Transaction, HederaAccount>["signOperation"] =>
+  ): AccountBridge<Transaction, Account>["signOperation"] =>
   ({ account, transaction, deviceId }) =>
     new Observable(o => {
       void (async function () {
@@ -65,15 +64,6 @@ 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,14 +107,6 @@ 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
@@ -167,7 +159,6 @@ 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).toEqual([]);
+      expect(result).toHaveLength(0);
     });
 
     it("returns sub account for mirror token with no operations yet (e.g. right after association)", async () => {
@@ -237,6 +237,7 @@ describe("utils", () => {
         erc20Tokens: [],
       });
 
+      expect(result).toHaveLength(1);
       expect(result).toMatchObject([
         {
           token: tokenCurrencyFromCAL,
@@ -258,6 +259,7 @@ describe("utils", () => {
         erc20Tokens: [{ balance: new BigNumber(42), token: tokenCurrencyFromCAL }],
       });
 
+      expect(result).toHaveLength(1);
       expect(result).toMatchObject([
         {
           token: tokenCurrencyFromCAL,
@@ -339,6 +341,7 @@ describe("utils", () => {
         hash: incomingTxHash,
         blockHash: incomingERC20Transaction.blockHash,
       });
+      expect(incomingOp?.subOperations).toHaveLength(1);
       expect(incomingOp?.subOperations).toMatchObject([
         {
           type: "IN",
@@ -350,6 +353,7 @@ describe("utils", () => {
           recipients: [address],
         },
       ]);
+      expect(newERC20TokenOperations).toHaveLength(1);
       expect(newERC20TokenOperations).toMatchObject([incomingOp?.subOperations?.[0]]);
       expect(updatedOperations).toHaveLength(oldMirrorOperations.length + 1);
     });
@@ -418,6 +422,7 @@ describe("utils", () => {
         blockHash: allowanceERC20Transaction.blockHash,
         standard: "erc20",
       });
+      expect(allowanceOp?.subOperations).toHaveLength(1);
       expect(allowanceOp?.subOperations).toMatchObject([
         {
           type: "OUT",
@@ -429,6 +434,7 @@ describe("utils", () => {
           recipients: [allowanceTxTo],
         },
       ]);
+      expect(newERC20TokenOperations).toHaveLength(1);
       expect(newERC20TokenOperations).toMatchObject([allowanceOp?.subOperations?.[0]]);
       expect(updatedOperations).toHaveLength(oldMirrorOperations.length + 1);
     });
@@ -513,7 +519,7 @@ describe("utils", () => {
       );
 
       expect(updatedOperations).toHaveLength(2);
-      expect(duplicatedContractCalls).toEqual([]);
+      expect(duplicatedContractCalls).toHaveLength(0);
       expect(feesOps).toHaveLength(1);
       expect(feesOps).toMatchObject([{ blockHash: "0xBLOCK" }]);
     });
@@ -547,7 +553,7 @@ describe("utils", () => {
 
       expect(pendingOp).toBeUndefined();
       expect(updatedOperations).toHaveLength(1);
-      expect(updatedOperations).toMatchObject([{ hash: "confirmed_tx" }]);
+      expect(updatedOperations[0].hash).toBe("confirmed_tx");
     });
 
     /**
@@ -666,6 +672,7 @@ describe("utils", () => {
           },
         ],
       });
+      expect(newERC20TokenOperations).toHaveLength(1);
       expect(newERC20TokenOperations).toMatchObject([
         {
           type: "OUT",

package/src/constants.ts

@@ -7,17 +7,12 @@ 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",
@@ -44,15 +39,6 @@ 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
  *
@@ -63,7 +49,6 @@ export enum HEDERA_DELEGATION_STATUS {
  * 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,
@@ -99,10 +84,3 @@ 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.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, isStakingTransaction } from "./logic/utils";
+import { isTokenAssociateTransaction } from "./logic/utils";
 import type { Transaction, TransactionStatus } from "./types";
 
 async function getDeviceTransactionConfig({
@@ -15,42 +15,6 @@ 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,10 +16,3 @@ export const HederaRecipientTokenAssociationUnverified = createCustomErrorClass(
 export const HederaRecipientEvmAddressVerificationRequired = createCustomErrorClass(
   "HederaRecipientEvmAddressVerificationRequired",
 );
-export const HederaRedundantStakingNodeIdError = createCustomErrorClass(
-  "HederaRedundantStakingNodeIdError",
-);
-export const HederaInvalidStakingNodeIdError = createCustomErrorClass(
-  "HederaInvalidStakingNodeIdError",
-);
-export const HederaNoStakingRewardsError = createCustomErrorClass("HederaNoStakingRewardsError");

package/src/logic/craftTransaction.ts

@@ -2,7 +2,6 @@ import BigNumber from "bignumber.js";
 import invariant from "invariant";
 import {
   AccountId,
-  AccountUpdateTransaction,
   ContractExecuteTransaction,
   ContractFunctionParameters,
   ContractId,
@@ -14,7 +13,7 @@ import {
 import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/index";
 import { DEFAULT_GAS_LIMIT, HEDERA_TRANSACTION_MODES } from "../constants";
 import type { HederaMemo, HederaTxData } from "../types";
-import { hasSpecificIntentData, serializeTransaction } from "./utils";
+import { serializeTransaction } from "./utils";
 
 // avoid "sign" prompt loop by having only one node (one transaction)
 // https://github.com/LedgerHQ/ledger-live/pull/72/commits/1e942687d4301660e43e0c4b5419fcfa2733b290
@@ -56,14 +55,6 @@ interface BuilderTokenAssociateTransaction extends BuilderCommonTransactionField
   tokenId: string;
 }
 
-interface BuilderUpdateAccountTransaction extends BuilderCommonTransactionFields {
-  type:
-    | HEDERA_TRANSACTION_MODES.Delegate
-    | HEDERA_TRANSACTION_MODES.Undelegate
-    | HEDERA_TRANSACTION_MODES.Redelegate;
-  stakingNodeId: number | null | undefined;
-}
-
 async function buildUnsignedCoinTransaction({
   account,
   transaction,
@@ -168,42 +159,13 @@ async function buildTokenAssociateTransaction({
   return tx.freeze();
 }
 
-async function buildUnsignedUpdateAccountTransaction({
-  account,
-  transaction,
-}: {
-  account: BuilderOperator;
-  transaction: BuilderUpdateAccountTransaction;
-}): Promise<AccountUpdateTransaction> {
-  const accountId = account.accountId;
-
-  const tx = new AccountUpdateTransaction()
-    .setNodeAccountIds([new AccountId(3)])
-    .setTransactionId(TransactionId.generate(accountId))
-    .setTransactionMemo(transaction.memo ?? "")
-    .setAccountId(accountId);
-
-  if (transaction.maxFee) {
-    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
-  }
-
-  if (typeof transaction.stakingNodeId === "number") {
-    tx.setStakedNodeId(transaction.stakingNodeId);
-  }
-
-  if (transaction.stakingNodeId === null) {
-    tx.clearStakedNodeId();
-  }
-
-  return tx.freeze();
-}
-
 export async function craftTransaction(
   txIntent: TransactionIntent<HederaMemo, HederaTxData>,
   customFees?: FeeEstimation,
 ) {
-  const account = { accountId: txIntent.sender };
-  const maxFee = customFees ? new BigNumber(customFees.value.toString()) : undefined;
+  const account = {
+    accountId: txIntent.sender,
+  };
 
   let tx;
 
@@ -217,7 +179,7 @@ export async function craftTransaction(
         type: txIntent.type,
         tokenId: txIntent.asset.assetReference,
         memo: txIntent.memo.value,
-        maxFee,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
       },
     });
   } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "hts") {
@@ -233,16 +195,17 @@ export async function craftTransaction(
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
-        maxFee,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
       },
     });
   } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "erc20") {
     invariant("assetReference" in txIntent.asset, "hedera: no assetReference in token transfer");
 
     const amount = new BigNumber(txIntent.amount.toString());
-    const gasLimit = hasSpecificIntentData(txIntent, "erc20")
-      ? new BigNumber(txIntent.data.gasLimit.toString())
-      : DEFAULT_GAS_LIMIT;
+    const gasLimit =
+      "data" in txIntent && txIntent.data.gasLimit
+        ? new BigNumber(txIntent.data.gasLimit.toString())
+        : DEFAULT_GAS_LIMIT;
 
     tx = await buildUnsignedERC20TokenTransaction({
       account,
@@ -252,31 +215,11 @@ export async function craftTransaction(
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
-        maxFee,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
         gasLimit,
       },
     });
-  } else if (
-    txIntent.type === HEDERA_TRANSACTION_MODES.Redelegate ||
-    txIntent.type === HEDERA_TRANSACTION_MODES.Undelegate ||
-    txIntent.type === HEDERA_TRANSACTION_MODES.Delegate
-  ) {
-    const stakingNodeId = hasSpecificIntentData(txIntent, "staking")
-      ? txIntent.data.stakingNodeId
-      : undefined;
-
-    tx = await buildUnsignedUpdateAccountTransaction({
-      account,
-      transaction: {
-        type: txIntent.type,
-        memo: txIntent.memo.value,
-        maxFee,
-        stakingNodeId,
-      },
-    });
-  }
-  // HEDERA_TRANSACTION_MODES.ClaimRewards is just a coin transfer that triggers staking rewards claim
-  else {
+  } else {
     const amount = new BigNumber(txIntent.amount.toString());
 
     tx = await buildUnsignedCoinTransaction({
@@ -286,7 +229,7 @@ export async function craftTransaction(
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
-        maxFee,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
       },
     });
   }

package/src/logic/getBalance.test.ts

@@ -29,6 +29,7 @@ describe("getBalance", () => {
     expect(apiClient.getAccount).toHaveBeenCalledWith(address);
     expect(apiClient.getAccountTokens).toHaveBeenCalledTimes(1);
     expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
+    expect(result).toHaveLength(1);
     expect(result).toEqual([
       {
         asset: { type: "native" },
@@ -79,6 +80,7 @@ describe("getBalance", () => {
     expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
     expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledTimes(1);
     expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledWith("0.0.7890", "hedera");
+    expect(result).toHaveLength(2);
     expect(result).toEqual(
       expect.arrayContaining([
         {
@@ -148,22 +150,21 @@ describe("getBalance", () => {
 
     const result = await getBalance(mockCurrency, address);
 
-    expect(result).toEqual([
-      {
-        asset: { type: "native" },
-        value: BigInt("1000000000"),
-      },
-      {
-        value: BigInt("5000"),
-        asset: {
-          type: mockTokenHTS.tokenType,
-          assetReference: mockTokenHTS.contractAddress,
-          assetOwner: address,
-          name: mockTokenHTS.name,
-          unit: mockTokenHTS.units[0],
-        },
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({
+      asset: { type: "native" },
+      value: BigInt("1000000000"),
+    });
+    expect(result[1]).toEqual({
+      value: BigInt("5000"),
+      asset: {
+        type: mockTokenHTS.tokenType,
+        assetReference: mockTokenHTS.contractAddress,
+        assetOwner: address,
+        name: mockTokenHTS.name,
+        unit: mockTokenHTS.units[0],
       },
-    ]);
+    });
   });
 
   it("should throw when failing to getAccount data", async () => {

package/src/logic/getBlock.ts

@@ -7,7 +7,7 @@ import type {
 import { getBlockInfo } from "./getBlockInfo";
 import { apiClient } from "../network/api";
 import type { HederaMirrorCoinTransfer, HederaMirrorTokenTransfer } from "../types";
-import { getMemoFromBase64, getTimestampRangeFromBlockHeight } from "./utils";
+import { getTimestampRangeFromBlockHeight } from "./utils";
 
 function toHederaAsset(
   mirrorTransfer: HederaMirrorCoinTransfer | HederaMirrorTokenTransfer,
@@ -64,7 +64,6 @@ export async function getBlock(height: number): Promise<Block> {
       operations,
       fees: BigInt(tx.charged_tx_fee),
       feesPayer: payerAccount,
-      details: { memo: getMemoFromBase64(tx.memo_base64) },
     };
   });