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

package/src/api/index.test.ts

@@ -21,10 +21,13 @@ describe("createApi", () => {
     expect(api.combine).toBeInstanceOf(Function);
     expect(api.craftTransaction).toBeInstanceOf(Function);
     expect(api.estimateFees).toBeInstanceOf(Function);
+    expect(api.getAssetFromToken).toBeInstanceOf(Function);
     expect(api.getBalance).toBeInstanceOf(Function);
+    expect(api.getBlock).toBeInstanceOf(Function);
+    expect(api.getBlockInfo).toBeInstanceOf(Function);
+    expect(api.getTokenFromAsset).toBeInstanceOf(Function);
+    expect(api.getValidators).toBeInstanceOf(Function);
     expect(api.lastBlock).toBeInstanceOf(Function);
     expect(api.listOperations).toBeInstanceOf(Function);
-    expect(api.getAssetFromToken).toBeInstanceOf(Function);
-    expect(api.getTokenFromAsset).toBeInstanceOf(Function);
   });
 });

package/src/api/index.ts

@@ -1,13 +1,11 @@
 import type {
   Api,
   CraftedTransaction,
-  Cursor,
   Operation,
   Page,
   Reward,
   Stake,
   TransactionValidation,
-  Validator,
 } from "@ledgerhq/coin-framework/api/index";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import coinConfig from "../config";
@@ -24,6 +22,7 @@ import {
   getAssetFromToken,
   getTokenFromAsset,
   lastBlock,
+  getValidators,
 } from "../logic/index";
 import { mapIntentToSDKOperation, getOperationValue } from "../logic/utils";
 import { apiClient } from "../network/api";
@@ -116,6 +115,9 @@ export function createApi(config: Record<string, never>): Api<HederaMemo> {
             ...liveOp.extra,
             ledgerOpType: liveOp.type,
             ...(asset.type !== "native" && { assetAmount: liveOp.value.toFixed(0) }),
+            ...(liveOp.extra.stakedAmount && {
+              stakedAmount: BigInt(liveOp.extra.stakedAmount.toFixed(0)),
+            }),
           },
           tx: {
             hash: liveOp.hash,
@@ -133,6 +135,7 @@ export function createApi(config: Record<string, never>): Api<HederaMemo> {
     },
     getTokenFromAsset: asset => getTokenFromAsset(currency, asset),
     getAssetFromToken,
+    getValidators: cursor => getValidators(cursor),
     validateIntent: async (_transactionIntent, _customFees): Promise<TransactionValidation> => {
       throw new Error("validateIntent is not supported");
     },
@@ -145,8 +148,5 @@ export function createApi(config: Record<string, never>): Api<HederaMemo> {
     getRewards: async (_address, _cursor): Promise<Page<Reward>> => {
       throw new Error("getRewards is not supported");
     },
-    getValidators(_cursor?: Cursor): Promise<Page<Validator>> {
-      throw new Error("getValidators is not supported");
-    },
   };
 }

package/src/bridge/{buildOptimisticOperation.integration.test.ts → buildOptimisticOperation.test.ts}

@@ -1,7 +1,6 @@
 import BigNumber from "bignumber.js";
 import { buildOptimisticOperation } from "./buildOptimisticOperation";
-import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
-import { estimateFees } from "../logic/estimateFees";
+import { HEDERA_TRANSACTION_MODES } from "../constants";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import {
   getMockedERC20TokenCurrency,
@@ -17,16 +16,12 @@ describe("buildOptimisticOperation", () => {
       mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
       amount: new BigNumber(0),
       recipient: "0.0.1234",
+      maxFee: new BigNumber(1000),
       properties: {
         token: mockedToken,
       },
     });
 
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.TokenAssociate,
-    });
-
     const op = await buildOptimisticOperation({
       account: mockedAccount,
       transaction: mockedTransaction,
@@ -34,7 +29,7 @@ describe("buildOptimisticOperation", () => {
 
     expect(op.type).toBe("ASSOCIATE_TOKEN");
     expect(op.extra).toEqual({ associatedTokenId: mockedToken.contractAddress });
-    expect(op.fee).toEqual(estimatedFee.tinybars);
+    expect(op.fee).toEqual(mockedTransaction.maxFee);
     expect(op.senders).toContain(mockedAccount.freshAddress);
     expect(op.recipients).toContain("0.0.1234");
   });
@@ -44,11 +39,7 @@ describe("buildOptimisticOperation", () => {
     const mockedTransaction = getMockedTransaction({
       amount: new BigNumber(123),
       recipient: "0.0.5678",
-    });
-
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+      maxFee: new BigNumber(1500),
     });
 
     const op = await buildOptimisticOperation({
@@ -57,14 +48,13 @@ describe("buildOptimisticOperation", () => {
     });
 
     expect(op.type).toBe("OUT");
-    expect(op.fee).toEqual(estimatedFee.tinybars);
+    expect(op.fee).toEqual(mockedTransaction.maxFee);
     expect(op.value).toEqual(new BigNumber(123));
     expect(op.senders).toContain(mockedAccount.freshAddress);
     expect(op.recipients).toContain("0.0.5678");
   });
 
   it("builds optimistic operation for HTS token", async () => {
-    const mockedAccount = getMockedAccount();
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const tokenAccount = getMockedTokenAccount(mockedTokenCurrency);
     const parentAccount = getMockedAccount({ subAccounts: [tokenAccount] });
@@ -72,11 +62,7 @@ describe("buildOptimisticOperation", () => {
       subAccountId: tokenAccount.id,
       amount: new BigNumber(123),
       recipient: "0.0.9999",
-    });
-
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.TokenTransfer,
+      maxFee: new BigNumber(2000),
     });
 
     const op = await buildOptimisticOperation({
@@ -86,11 +72,11 @@ describe("buildOptimisticOperation", () => {
     const subOp = (op.subOperations ?? [])[0];
 
     expect(op.type).toBe("FEES");
-    expect(op.value).toEqual(estimatedFee.tinybars);
+    expect(op.value).toEqual(mockedTransaction.maxFee);
     expect(op.subOperations).toHaveLength(1);
     expect(subOp.type).toBe("OUT");
     expect(subOp.value).toEqual(new BigNumber(123));
-    expect(subOp.fee).toEqual(estimatedFee.tinybars);
+    expect(subOp.fee).toEqual(mockedTransaction.maxFee);
     expect(subOp.accountId).toBe(tokenAccount.id);
     expect(subOp.recipients).toContain("0.0.9999");
   });
@@ -103,22 +89,7 @@ describe("buildOptimisticOperation", () => {
       subAccountId: tokenAccount.id,
       amount: new BigNumber(123),
       recipient: "0.0.9999",
-    });
-
-    const estimatedFee = await estimateFees({
-      operationType: HEDERA_OPERATION_TYPES.ContractCall,
-      txIntent: {
-        intentType: "transaction",
-        type: HEDERA_TRANSACTION_MODES.Send,
-        asset: {
-          type: "erc20",
-          assetReference: tokenAccount.token.contractAddress,
-          assetOwner: parentAccount.freshAddress,
-        },
-        amount: BigInt(mockedTransaction.amount.toString()),
-        sender: parentAccount.freshAddress,
-        recipient: mockedTransaction.recipient,
-      },
+      maxFee: new BigNumber(2500),
     });
 
     const op = await buildOptimisticOperation({
@@ -128,11 +99,11 @@ describe("buildOptimisticOperation", () => {
     const subOp = (op.subOperations ?? [])[0];
 
     expect(op.type).toBe("FEES");
-    expect(op.value).toEqual(estimatedFee.tinybars);
+    expect(op.value).toEqual(mockedTransaction.maxFee);
     expect(op.subOperations).toHaveLength(1);
     expect(subOp.type).toBe("OUT");
     expect(subOp.value).toEqual(new BigNumber(123));
-    expect(subOp.fee).toEqual(estimatedFee.tinybars);
+    expect(subOp.fee).toEqual(mockedTransaction.maxFee);
     expect(subOp.accountId).toBe(tokenAccount.id);
     expect(subOp.recipients).toContain("0.0.9999");
   });
@@ -144,23 +115,19 @@ describe("buildOptimisticOperation", () => {
       mode: HEDERA_TRANSACTION_MODES.Delegate,
       amount: new BigNumber(0),
       recipient: "",
+      maxFee: new BigNumber(1200),
       properties: {
         stakingNodeId,
       },
     });
 
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.CryptoUpdate,
-    });
-
     const op = await buildOptimisticOperation({
       account: mockedAccount,
       transaction: mockedTransaction,
     });
 
-    expect(op.type).toBe("UPDATE_ACCOUNT");
-    expect(op.fee).toEqual(estimatedFee.tinybars);
+    expect(op.type).toBe("DELEGATE");
+    expect(op.fee).toEqual(mockedTransaction.maxFee);
     expect(op.value).toEqual(new BigNumber(0));
     expect(op.senders).toContain(mockedAccount.freshAddress);
     expect(op.extra).toEqual({
@@ -188,15 +155,11 @@ describe("buildOptimisticOperation", () => {
       mode: HEDERA_TRANSACTION_MODES.Redelegate,
       amount: new BigNumber(0),
       recipient: "",
+      maxFee: new BigNumber(1300),
+      memo: "Redelegating to better validator",
       properties: {
         stakingNodeId: newNodeId,
       },
-      memo: "Redelegating to better validator",
-    });
-
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.CryptoUpdate,
     });
 
     const op = await buildOptimisticOperation({
@@ -204,8 +167,8 @@ describe("buildOptimisticOperation", () => {
       transaction: mockedTransaction,
     });
 
-    expect(op.type).toBe("UPDATE_ACCOUNT");
-    expect(op.fee).toEqual(estimatedFee.tinybars);
+    expect(op.type).toBe("REDELEGATE");
+    expect(op.fee).toEqual(mockedTransaction.maxFee);
     expect(op.extra).toEqual({
       memo: "Redelegating to better validator",
       targetStakingNodeId: newNodeId,
@@ -230,23 +193,19 @@ describe("buildOptimisticOperation", () => {
       mode: HEDERA_TRANSACTION_MODES.Undelegate,
       amount: new BigNumber(0),
       recipient: "",
+      maxFee: new BigNumber(1100),
       properties: {
         stakingNodeId: null,
       },
     });
 
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.CryptoUpdate,
-    });
-
     const op = await buildOptimisticOperation({
       account: mockedAccount,
       transaction: mockedTransaction,
     });
 
-    expect(op.type).toBe("UPDATE_ACCOUNT");
-    expect(op.fee).toEqual(estimatedFee.tinybars);
+    expect(op.type).toBe("UNDELEGATE");
+    expect(op.fee).toEqual(mockedTransaction.maxFee);
     expect(op.value).toEqual(new BigNumber(0));
     expect(op.extra).toEqual({
       memo: null,
@@ -272,21 +231,17 @@ describe("buildOptimisticOperation", () => {
       mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
       amount: new BigNumber(0),
       recipient: "",
+      maxFee: new BigNumber(1400),
       memo: "Claiming staking rewards",
     });
 
-    const estimatedFee = await estimateFees({
-      currency: mockedAccount.currency,
-      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
-    });
-
     const op = await buildOptimisticOperation({
       account: mockedAccount,
       transaction: mockedTransaction,
     });
 
     expect(op.type).toBe("OUT");
-    expect(op.fee).toEqual(estimatedFee.tinybars);
+    expect(op.fee).toEqual(mockedTransaction.maxFee);
     expect(op.extra).toEqual({
       memo: "Claiming staking rewards",
     });

package/src/bridge/buildOptimisticOperation.ts

@@ -3,8 +3,7 @@ import invariant from "invariant";
 import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
-import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
-import { estimateFees } from "../logic/estimateFees";
+import { HEDERA_TRANSACTION_MODES, MAP_STAKING_MODE_TO_OPERATION_TYPE } from "../constants";
 import {
   safeParseAccountId,
   isTokenAssociateTransaction,
@@ -21,18 +20,15 @@ const buildOptimisticTokenAssociateOperation = async ({
 }): Promise<Operation> => {
   invariant(isTokenAssociateTransaction(transaction), "invalid transaction properties");
 
-  const estimatedFee = await estimateFees({
-    currency: account.currency,
-    operationType: HEDERA_OPERATION_TYPES.TokenAssociate,
-  });
+  const fee = transaction.maxFee ?? new BigNumber(0);
   const type: OperationType = "ASSOCIATE_TOKEN";
 
   const operation: Operation = {
     id: encodeOperationId(account.id, "", type),
     hash: "",
     type,
-    value: estimatedFee.tinybars,
-    fee: estimatedFee.tinybars,
+    value: fee,
+    fee,
     blockHash: null,
     blockHeight: null,
     senders: [account.freshAddress.toString()],
@@ -56,13 +52,8 @@ const buildOptimisticCoinOperation = async ({
   transaction: Transaction;
   transactionType?: OperationType;
 }): Promise<Operation> => {
-  const estimatedFee =
-    transactionType === "FEES"
-      ? transaction.amount
-      : await estimateFees({
-          currency: account.currency,
-          operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
-        });
+  const fee =
+    transactionType === "FEES" ? transaction.amount : transaction.maxFee ?? new BigNumber(0);
   const value = transaction.amount;
   const type: OperationType = transactionType ?? "OUT";
   const [_, recipientAddress] = safeParseAccountId(transaction.recipient);
@@ -74,7 +65,7 @@ const buildOptimisticCoinOperation = async ({
     hash: "",
     type,
     value,
-    fee: BigNumber.isBigNumber(estimatedFee) ? estimatedFee : estimatedFee.tinybars,
+    fee,
     blockHash: null,
     blockHeight: null,
     senders: [account.freshAddress.toString()],
@@ -98,10 +89,7 @@ const buildOptimisticHTSTokenOperation = async ({
   tokenAccount: TokenAccount;
   transaction: Transaction;
 }): Promise<Operation> => {
-  const estimatedFee = await estimateFees({
-    currency: account.currency,
-    operationType: HEDERA_OPERATION_TYPES.TokenTransfer,
-  });
+  const fee = transaction.maxFee ?? new BigNumber(0);
   const value = transaction.amount;
   const type: OperationType = "OUT";
   const [_, recipientAddress] = safeParseAccountId(transaction.recipient);
@@ -112,7 +100,7 @@ const buildOptimisticHTSTokenOperation = async ({
     account,
     transaction: {
       ...transaction,
-      amount: estimatedFee.tinybars,
+      amount: fee,
     },
     transactionType: "FEES",
   });
@@ -125,7 +113,7 @@ const buildOptimisticHTSTokenOperation = async ({
         hash: "",
         type,
         value,
-        fee: estimatedFee.tinybars,
+        fee,
         blockHash: null,
         blockHeight: null,
         senders: [account.freshAddress.toString()],
@@ -151,21 +139,7 @@ const buildOptimisticERC20TokenOperation = async ({
   tokenAccount: TokenAccount;
   transaction: Transaction;
 }): Promise<Operation> => {
-  const estimatedFees = await estimateFees({
-    operationType: HEDERA_OPERATION_TYPES.ContractCall,
-    txIntent: {
-      intentType: "transaction",
-      type: HEDERA_TRANSACTION_MODES.Send,
-      asset: {
-        type: "erc20",
-        assetReference: tokenAccount.token.contractAddress,
-        assetOwner: account.freshAddress,
-      },
-      amount: BigInt(transaction.amount.toString()),
-      sender: account.freshAddress,
-      recipient: transaction.recipient,
-    },
-  });
+  const fee = transaction.maxFee ?? new BigNumber(0);
   const value = transaction.amount;
   const type: OperationType = "OUT";
   const memo = transaction.memo;
@@ -174,7 +148,7 @@ const buildOptimisticERC20TokenOperation = async ({
     account,
     transaction: {
       ...transaction,
-      amount: estimatedFees.tinybars,
+      amount: fee,
     },
     transactionType: "FEES",
   });
@@ -187,7 +161,7 @@ const buildOptimisticERC20TokenOperation = async ({
         hash: "",
         type,
         value,
-        fee: estimatedFees.tinybars,
+        fee,
         blockHash: null,
         blockHeight: null,
         senders: [account.freshAddress.toString()],
@@ -213,19 +187,16 @@ const buildOptimisticUpdateAccountOperation = async ({
 }): Promise<Operation> => {
   invariant(isStakingTransaction(transaction), "invalid transaction properties");
 
-  const estimatedFee = await estimateFees({
-    operationType: HEDERA_OPERATION_TYPES.CryptoUpdate,
-    currency: account.currency,
-  });
+  const fee = transaction.maxFee ?? new BigNumber(0);
   const value = transaction.amount;
-  const type: OperationType = "UPDATE_ACCOUNT";
+  const type: OperationType = MAP_STAKING_MODE_TO_OPERATION_TYPE[transaction.mode];
 
   const operation: Operation = {
     id: encodeOperationId(account.id, "", type),
     hash: "",
     type,
     value,
-    fee: estimatedFee.tinybars,
+    fee,
     blockHash: null,
     blockHeight: null,
     senders: [account.freshAddress.toString()],

package/src/bridge/index.ts

@@ -19,6 +19,7 @@ import { getAccountShape, buildIterateResult, postSync } from "./synchronisation
 import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
 import resolver from "../signer/index";
 import type { Transaction, TransactionStatus, HederaSigner, HederaAccount } from "../types";
+import { validateAddress } from "./validateAddress";
 
 function buildCurrencyBridge(signerContext: SignerContext<HederaSigner>): CurrencyBridge {
   const getAddress = resolver(signerContext);
@@ -62,6 +63,7 @@ function buildAccountBridge(
     },
     broadcast,
     getSerializedAddressParameters,
+    validateAddress,
   };
 }
 

package/src/bridge/validateAddress.test.ts

@@ -0,0 +1,31 @@
+import { safeParseAccountId } from "../logic/utils";
+import { validateAddress } from "./validateAddress";
+
+jest.mock("../logic/utils");
+
+describe("validateAddress", () => {
+  const mockedSafeParseAccountId = jest.mocked(safeParseAccountId);
+
+  beforeEach(() => {
+    mockedSafeParseAccountId.mockClear();
+  });
+
+  it.each([true, false])(
+    "should call safeParseAccountId and return expected value (%s)",
+    async (expectedValue: boolean) => {
+      if (expectedValue) {
+        mockedSafeParseAccountId.mockReturnValueOnce([null, { accountId: "", checksum: "" }]);
+      } else {
+        mockedSafeParseAccountId.mockReturnValueOnce([new Error(), null]);
+      }
+
+      const address = "some random address";
+      const parameters = {};
+      const result = await validateAddress(address, parameters);
+      expect(result).toEqual(expectedValue);
+
+      expect(mockedSafeParseAccountId).toHaveBeenCalledTimes(1);
+      expect(mockedSafeParseAccountId).toHaveBeenCalledWith(address);
+    },
+  );
+});

package/src/bridge/validateAddress.ts

@@ -0,0 +1,10 @@
+import { AddressValidationCurrencyParameters } from "@ledgerhq/types-live";
+import { safeParseAccountId } from "../logic/utils";
+
+export async function validateAddress(
+  address: string,
+  _parameters: Partial<AddressValidationCurrencyParameters>,
+): Promise<boolean> {
+  const [error] = safeParseAccountId(address);
+  return error === null;
+}

package/src/constants.ts

@@ -1,4 +1,5 @@
 import BigNumber from "bignumber.js";
+import type { OperationType } from "@ledgerhq/types-live";
 
 /**
  * Internal types to distinguish custom Hedera transaction behaviors.
@@ -13,6 +14,14 @@ export enum HEDERA_TRANSACTION_MODES {
   ClaimRewards = "claim-rewards",
 }
 
+/**
+ * Enum representing Hedera transaction names used in the Hedera Mirror Node API.
+ */
+export enum HEDERA_TRANSACTION_NAMES {
+  ContractCall = "CONTRACTCALL",
+  UpdateAccount = "CRYPTOUPDATEACCOUNT",
+}
+
 /**
  * Enum representing the supported Hedera operation types for fee estimation
  */
@@ -100,9 +109,22 @@ export const SUPPORTED_ERC20_TOKENS = [
   },
 ];
 
-export const MAP_STAKING_MODE_TO_MEMO = {
+export const MAP_STAKING_MODE_TO_MEMO: Record<string, string> = {
   [HEDERA_TRANSACTION_MODES.ClaimRewards]: "Collect Staking Rewards",
   [HEDERA_TRANSACTION_MODES.Delegate]: "Stake",
   [HEDERA_TRANSACTION_MODES.Undelegate]: "Unstake",
   [HEDERA_TRANSACTION_MODES.Redelegate]: "Restake",
 } as const;
+
+export const MAP_STAKING_MODE_TO_OPERATION_TYPE: Record<string, OperationType> = {
+  [HEDERA_TRANSACTION_MODES.Delegate]: "DELEGATE",
+  [HEDERA_TRANSACTION_MODES.Undelegate]: "UNDELEGATE",
+  [HEDERA_TRANSACTION_MODES.Redelegate]: "REDELEGATE",
+};
+
+export const MAP_STAKING_MODE_TO_METHOD: Record<string, string> = {
+  [HEDERA_TRANSACTION_MODES.Delegate]: "Delegate",
+  [HEDERA_TRANSACTION_MODES.Undelegate]: "Undelegate",
+  [HEDERA_TRANSACTION_MODES.Redelegate]: "Redelegate",
+  [HEDERA_TRANSACTION_MODES.ClaimRewards]: "Claim Rewards",
+};