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

package/src/bridge/getTransactionStatus.test.ts

@@ -4,18 +4,24 @@ import {
   InvalidAddressBecauseDestinationIsAlsoSource,
   AmountRequired,
   NotEnoughBalance,
+  ClaimRewardsFeesWarning,
+  RecipientRequired,
 } from "@ledgerhq/errors";
 import { HEDERA_TRANSACTION_MODES } from "../constants";
 import {
   HederaInsufficientFundsForAssociation,
+  HederaInvalidStakingNodeIdError,
+  HederaNoStakingRewardsError,
   HederaRecipientEvmAddressVerificationRequired,
   HederaRecipientInvalidChecksum,
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
+  HederaRedundantStakingNodeIdError,
 } from "../errors";
 import { getTransactionStatus } from "./getTransactionStatus";
 import * as estimateFees from "../logic/estimateFees";
 import * as logicUtils from "../logic/utils";
+import * as preloadData from "../preload-data";
 import { rpcClient } from "../network/rpc";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import {
@@ -23,26 +29,28 @@ import {
   getMockedHTSTokenCurrency,
 } from "../test/fixtures/currency.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
-import type { EstimateFeesResult } from "../types";
+import type { EstimateFeesResult, HederaPreloadData } from "../types";
 
 describe("getTransactionStatus", () => {
   const mockedEstimatedFee: EstimateFeesResult = { tinybars: new BigNumber(1) };
   const mockedUsdRate = new BigNumber(1);
+  const mockPreload = { validators: [{ nodeId: 1 }, { nodeId: 2 }] } as HederaPreloadData;
   const validRecipientAddress = "0.0.1234567";
   const validRecipientAddressWithChecksum = "0.0.1234567-ylkls";
 
   beforeEach(() => {
     jest.clearAllMocks();
 
-    jest.spyOn(logicUtils, "getCurrencyToUSDRate").mockResolvedValueOnce(mockedUsdRate);
     jest.spyOn(estimateFees, "estimateFees").mockResolvedValueOnce(mockedEstimatedFee);
+    jest.spyOn(logicUtils, "getCurrencyToUSDRate").mockResolvedValueOnce(mockedUsdRate);
+    jest.spyOn(preloadData, "getCurrentHederaPreloadData").mockReturnValueOnce(mockPreload);
   });
 
   afterAll(() => {
     rpcClient._resetInstance();
   });
 
-  test("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
+  it("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(1000) });
     const mockedTransaction = getMockedTransaction({
       recipient: validRecipientAddress,
@@ -57,7 +65,7 @@ describe("getTransactionStatus", () => {
     expect(result.totalSpent.isGreaterThan(100)).toBe(true);
   });
 
-  test("hts token transfer with valid recipient and sufficient balance completes successfully", async () => {
+  it("hts token transfer with valid recipient and sufficient balance completes successfully", async () => {
     jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(true);
 
     const tokenCurrency = getMockedHTSTokenCurrency();
@@ -76,7 +84,7 @@ describe("getTransactionStatus", () => {
     expect(result.amount).toEqual(new BigNumber(200));
   });
 
-  test("erc20 token transfer with valid recipient and sufficient balance completes successfully", async () => {
+  it("erc20 token transfer with valid recipient and sufficient balance completes successfully", async () => {
     const tokenCurrency = getMockedERC20TokenCurrency();
     const tokenAccount = getMockedTokenAccount(tokenCurrency, { balance: new BigNumber(500) });
     const account = getMockedAccount({ balance: new BigNumber(1000), subAccounts: [tokenAccount] });
@@ -95,7 +103,7 @@ describe("getTransactionStatus", () => {
     expect(result.amount).toEqual(new BigNumber(200));
   });
 
-  test("token associate transaction with sufficient USD worth completes successfully", async () => {
+  it("token associate transaction with sufficient USD worth completes successfully", async () => {
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
@@ -114,7 +122,7 @@ describe("getTransactionStatus", () => {
     expect(result.estimatedFees).toEqual(mockedEstimatedFee.tinybars);
   });
 
-  test("recipient with checksum is supported", async () => {
+  it("recipient with checksum is supported", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(1000) });
     const mockedTransaction = getMockedTransaction({
       recipient: validRecipientAddressWithChecksum,
@@ -127,22 +135,25 @@ describe("getTransactionStatus", () => {
     expect(result.warnings).toEqual({});
   });
 
-  test("adds error for invalid recipient address", async () => {
+  it("adds error for invalid recipient address", async () => {
     const mockedAccount = getMockedAccount();
 
-    const txWithInvalidAddress = getMockedTransaction({ recipient: "invalid_address" });
+    const txWithInvalidAddress1 = getMockedTransaction({ recipient: "" });
+    const txWithInvalidAddress2 = getMockedTransaction({ recipient: "invalid_address" });
     const txWithInvalidAddressChecksum = getMockedTransaction({ recipient: "0.0.9124531-invld" });
 
-    const [result1, result2] = await Promise.all([
-      getTransactionStatus(mockedAccount, txWithInvalidAddress),
+    const [result1, result2, result3] = await Promise.all([
+      getTransactionStatus(mockedAccount, txWithInvalidAddress1),
+      getTransactionStatus(mockedAccount, txWithInvalidAddress2),
       getTransactionStatus(mockedAccount, txWithInvalidAddressChecksum),
     ]);
 
-    expect(result1.errors.recipient).toBeInstanceOf(InvalidAddress);
-    expect(result2.errors.recipient).toBeInstanceOf(HederaRecipientInvalidChecksum);
+    expect(result1.errors.recipient).toBeInstanceOf(RecipientRequired);
+    expect(result2.errors.recipient).toBeInstanceOf(InvalidAddress);
+    expect(result3.errors.recipient).toBeInstanceOf(HederaRecipientInvalidChecksum);
   });
 
-  test("adds error for self transfers", async () => {
+  it("adds error for self transfers", async () => {
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
       recipient: mockedAccount.freshAddress,
@@ -153,7 +164,7 @@ describe("getTransactionStatus", () => {
     expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
   });
 
-  test("adds error during coin transfer with insufficient balance", async () => {
+  it("adds error during coin transfer with insufficient balance", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
     const mockedTransaction = getMockedTransaction({
       amount: new BigNumber(100),
@@ -165,7 +176,7 @@ describe("getTransactionStatus", () => {
     expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
   });
 
-  test("adds error if USD balance is too low for token association", async () => {
+  it("adds error if USD balance is too low for token association", async () => {
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
     const mockedTransaction = getMockedTransaction({
@@ -182,7 +193,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  test("adds warning during token transfer if recipient has no token associated", async () => {
+  it("adds warning during token transfer if recipient has no token associated", async () => {
     jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(false);
 
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
@@ -200,7 +211,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  test("adds evm address verification warning during ERC20 token transfer", async () => {
+  it("adds evm address verification warning during ERC20 token transfer", async () => {
     const mockedTokenCurrency = getMockedERC20TokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
     const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
@@ -216,7 +227,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  test("adds warning if token association status can't be verified", async () => {
+  it("adds warning if token association status can't be verified", async () => {
     jest
       .spyOn(logicUtils, "checkAccountTokenAssociationStatus")
       .mockRejectedValueOnce(new HederaRecipientTokenAssociationUnverified());
@@ -236,7 +247,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  test("adds error during token transfer with insufficient balance", async () => {
+  it("adds error during token transfer with insufficient balance", async () => {
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency, {
       balance: new BigNumber(0),
@@ -253,7 +264,7 @@ describe("getTransactionStatus", () => {
     expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
   });
 
-  test("adds error if amount is zero and useAllAmount is false", async () => {
+  it("adds error if amount is zero and useAllAmount is false", async () => {
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
       recipient: validRecipientAddress,
@@ -265,4 +276,163 @@ describe("getTransactionStatus", () => {
 
     expect(result.errors.amount).toBeInstanceOf(AmountRequired);
   });
+
+  it("delegate transaction with valid node completes successfully", async () => {
+    const account = getMockedAccount();
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Delegate,
+      properties: { stakingNodeId: 1 },
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.amount).toEqual(new BigNumber(0));
+  });
+
+  it("adds error for delegation without staking node id", async () => {
+    const account = getMockedAccount();
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Delegate,
+      properties: {} as any,
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors.missingStakingNodeId).toBeInstanceOf(HederaInvalidStakingNodeIdError);
+  });
+
+  it("adds error for delegation with invalid staking node id", async () => {
+    const account = getMockedAccount();
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Delegate,
+      properties: { stakingNodeId: 999 },
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors.stakingNodeId).toBeInstanceOf(HederaInvalidStakingNodeIdError);
+  });
+
+  it("adds error for delegation to already delegated node", async () => {
+    const account = getMockedAccount({
+      hederaResources: {
+        maxAutomaticTokenAssociations: 0,
+        isAutoTokenAssociationEnabled: false,
+        delegation: {
+          nodeId: 1,
+          pendingReward: new BigNumber(0),
+          delegated: new BigNumber(1000),
+        },
+      },
+    });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Delegate,
+      properties: { stakingNodeId: 1 },
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors.stakingNodeId).toBeInstanceOf(HederaRedundantStakingNodeIdError);
+  });
+
+  it("adds error during staking transfer with insufficient balance", async () => {
+    const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
+    const mockedDelegateTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Delegate,
+      properties: { stakingNodeId: 1 },
+    });
+    const mockedUndelegateTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Undelegate,
+      properties: { stakingNodeId: null },
+    });
+    const mockedRedelegateTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Redelegate,
+      properties: { stakingNodeId: 2 },
+    });
+    const mockedClaimRewardsTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
+    });
+
+    const [resultDelegate, resultUndelegate, resultRedelegate, resultClaimRewards] =
+      await Promise.all([
+        getTransactionStatus(mockedAccount, mockedDelegateTransaction),
+        getTransactionStatus(mockedAccount, mockedUndelegateTransaction),
+        getTransactionStatus(mockedAccount, mockedRedelegateTransaction),
+        getTransactionStatus(mockedAccount, mockedClaimRewardsTransaction),
+      ]);
+
+    expect(resultDelegate.errors.fee).toBeInstanceOf(NotEnoughBalance);
+    expect(resultUndelegate.errors.fee).toBeInstanceOf(NotEnoughBalance);
+    expect(resultRedelegate.errors.fee).toBeInstanceOf(NotEnoughBalance);
+    expect(resultClaimRewards.errors.fee).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("adds error when claiming rewards with no rewards available", async () => {
+    const account = getMockedAccount({
+      hederaResources: {
+        maxAutomaticTokenAssociations: 0,
+        isAutoTokenAssociationEnabled: false,
+        delegation: {
+          nodeId: 1,
+          pendingReward: new BigNumber(0),
+          delegated: new BigNumber(1000),
+        },
+      },
+    });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors.noRewardsToClaim).toBeInstanceOf(HederaNoStakingRewardsError);
+  });
+
+  it("adds warning when claiming rewards with fee higher than rewards", async () => {
+    const account = getMockedAccount({
+      hederaResources: {
+        maxAutomaticTokenAssociations: 0,
+        isAutoTokenAssociationEnabled: false,
+        delegation: {
+          nodeId: 1,
+          pendingReward: new BigNumber(10),
+          delegated: new BigNumber(1000),
+        },
+      },
+    });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
+      maxFee: new BigNumber(100),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.warnings.claimRewardsFee).toBeInstanceOf(ClaimRewardsFeesWarning);
+  });
+
+  it("claim rewards with sufficient rewards completes successfully", async () => {
+    const account = getMockedAccount({
+      hederaResources: {
+        maxAutomaticTokenAssociations: 0,
+        isAutoTokenAssociationEnabled: false,
+        delegation: {
+          nodeId: 1,
+          pendingReward: new BigNumber(100),
+          delegated: new BigNumber(1000),
+        },
+      },
+    });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
+      maxFee: new BigNumber(10),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.amount).toEqual(new BigNumber(0));
+  });
 });

package/src/bridge/getTransactionStatus.ts

@@ -1,9 +1,11 @@
 import BigNumber from "bignumber.js";
+import invariant from "invariant";
 import {
   AmountRequired,
   NotEnoughBalance,
   InvalidAddressBecauseDestinationIsAlsoSource,
   RecipientRequired,
+  ClaimRewardsFeesWarning,
 } from "@ledgerhq/errors";
 import type { Account, AccountBridge, TokenAccount } from "@ledgerhq/types-live";
 import { findSubAccountById } from "@ledgerhq/coin-framework/account";
@@ -14,6 +16,9 @@ import {
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
   HederaRecipientEvmAddressVerificationRequired,
+  HederaInvalidStakingNodeIdError,
+  HederaRedundantStakingNodeIdError,
+  HederaNoStakingRewardsError,
 } from "../errors";
 import { estimateFees } from "../logic/estimateFees";
 import {
@@ -22,8 +27,15 @@ import {
   getCurrencyToUSDRate,
   checkAccountTokenAssociationStatus,
   safeParseAccountId,
+  isStakingTransaction,
 } from "../logic/utils";
-import type { Transaction, TransactionStatus, TransactionTokenAssociate } from "../types";
+import { getCurrentHederaPreloadData } from "../preload-data";
+import type {
+  HederaAccount,
+  Transaction,
+  TransactionStatus,
+  TransactionTokenAssociate,
+} from "../types";
 import { calculateAmount } from "./utils";
 
 type Errors = Record<string, Error>;
@@ -241,6 +253,66 @@ async function handleCoinTransaction(
   };
 }
 
+async function handleStakingTransaction(account: HederaAccount, transaction: Transaction) {
+  invariant(isStakingTransaction(transaction), "invalid transaction properties");
+
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const { validators } = getCurrentHederaPreloadData(account.currency);
+  const estimatedFees = await estimateFees({
+    operationType: HEDERA_OPERATION_TYPES.CryptoUpdate,
+    currency: account.currency,
+  });
+  const amount = BigNumber(0);
+  const totalSpent = amount.plus(estimatedFees.tinybars);
+
+  if (
+    transaction.mode === HEDERA_TRANSACTION_MODES.Delegate ||
+    transaction.mode === HEDERA_TRANSACTION_MODES.Redelegate
+  ) {
+    if (typeof transaction.properties?.stakingNodeId === "number") {
+      const isValid = validators.some(validator => {
+        return validator.nodeId === transaction.properties?.stakingNodeId;
+      });
+
+      if (!isValid) {
+        errors.stakingNodeId = new HederaInvalidStakingNodeIdError();
+      }
+    } else {
+      errors.missingStakingNodeId = new HederaInvalidStakingNodeIdError("Validator must be set");
+    }
+
+    if (account.hederaResources?.delegation?.nodeId === transaction.properties?.stakingNodeId) {
+      errors.stakingNodeId = new HederaRedundantStakingNodeIdError();
+    }
+  }
+
+  if (transaction.mode === HEDERA_TRANSACTION_MODES.ClaimRewards) {
+    const rewardsToClaim = account.hederaResources?.delegation?.pendingReward || new BigNumber(0);
+    const transactionFee = transaction.maxFee ?? new BigNumber(0);
+
+    if (rewardsToClaim.lte(0)) {
+      errors.noRewardsToClaim = new HederaNoStakingRewardsError();
+    }
+
+    if (transactionFee.gt(rewardsToClaim)) {
+      warnings.claimRewardsFee = new ClaimRewardsFeesWarning();
+    }
+  }
+
+  if (account.balance.isLessThan(totalSpent)) {
+    errors.fee = new NotEnoughBalance("");
+  }
+
+  return {
+    amount: new BigNumber(0),
+    estimatedFees: estimatedFees.tinybars,
+    totalSpent,
+    errors,
+    warnings,
+  };
+}
+
 export const getTransactionStatus: AccountBridge<
   Transaction,
   Account,
@@ -258,6 +330,8 @@ export const getTransactionStatus: AccountBridge<
     return handleHTSTokenTransaction(account, subAccount, transaction);
   } else if (isERC20TokenTransaction) {
     return handleERC20TokenTransaction(account, subAccount, transaction);
+  } else if (isStakingTransaction(transaction)) {
+    return handleStakingTransaction(account, transaction);
   } else {
     return handleCoinTransaction(account, transaction);
   }

package/src/bridge/index.ts

@@ -13,6 +13,7 @@ import { estimateMaxSpendable } from "./estimateMaxSpendable";
 import { getTransactionStatus } from "./getTransactionStatus";
 import { prepareTransaction } from "./prepareTransaction";
 import { receive } from "./receive";
+import { getPreloadStrategy, hydrate, preload } from "../preload";
 import { buildSignOperation } from "./signOperation";
 import { getAccountShape, buildIterateResult, postSync } from "./synchronisation";
 import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
@@ -29,8 +30,9 @@ function buildCurrencyBridge(signerContext: SignerContext<HederaSigner>): Curren
   });
 
   return {
-    preload: () => Promise.resolve({}),
-    hydrate: () => {},
+    preload,
+    hydrate,
+    getPreloadStrategy,
     scanAccounts,
   };
 }

package/src/bridge/prepareTransaction.test.ts

@@ -1,32 +1,136 @@
 import BigNumber from "bignumber.js";
 import { estimateFees } from "../logic/estimateFees";
 import { prepareTransaction } from "./prepareTransaction";
-import { getMockedAccount } from "../test/fixtures/account.fixture";
+import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
 import * as utils from "./utils";
 import type { EstimateFeesResult } from "../types";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
+import {
+  getMockedERC20TokenCurrency,
+  getMockedHTSTokenCurrency,
+} from "../test/fixtures/currency.fixture";
 
 jest.mock("../logic/estimateFees");
 
 describe("prepareTransaction", () => {
   const mockAccount = getMockedAccount();
   const mockTx = getMockedTransaction();
-  const mockFeeEstimation: EstimateFeesResult = { tinybars: new BigNumber(10) };
+  const mockFeeEstimation: EstimateFeesResult = {
+    tinybars: new BigNumber(10),
+    gas: new BigNumber(5),
+  };
+  const mockCalculatedAmount = {
+    amount: new BigNumber(100),
+    totalSpent: new BigNumber(100),
+  };
 
   beforeEach(() => {
     jest.clearAllMocks();
 
     (estimateFees as jest.Mock).mockResolvedValue(mockFeeEstimation);
-    jest
-      .spyOn(utils, "calculateAmount")
-      .mockResolvedValue(
-        Promise.resolve({ amount: new BigNumber(100), totalSpent: new BigNumber(100) }),
-      );
+    jest.spyOn(utils, "calculateAmount").mockResolvedValue(mockCalculatedAmount);
   });
 
-  test("should set amount and maxFee from utils", async () => {
+  it("should set amount and maxFee from utils", async () => {
     const result = await prepareTransaction(mockAccount, mockTx);
+
     expect(result.amount).toStrictEqual(new BigNumber(100));
     expect(result.maxFee).toStrictEqual(new BigNumber(10));
   });
+
+  it("should build ContractCall estimation params with txIntent", async () => {
+    const mockTokenERC20 = getMockedERC20TokenCurrency();
+    const tokenAccount = getMockedTokenAccount(mockTokenERC20);
+    const accountWithToken = getMockedAccount({ subAccounts: [tokenAccount] });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Send,
+      subAccountId: tokenAccount.id,
+      amount: new BigNumber(5000),
+      recipient: "0.0.9999",
+    });
+
+    await prepareTransaction(accountWithToken, transaction);
+
+    expect(estimateFees).toHaveBeenCalledWith({
+      operationType: HEDERA_OPERATION_TYPES.ContractCall,
+      txIntent: {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        asset: {
+          type: mockTokenERC20.tokenType,
+          assetReference: mockTokenERC20.contractAddress,
+          assetOwner: accountWithToken.freshAddress,
+        },
+        amount: BigInt(5000),
+        sender: accountWithToken.freshAddress,
+        recipient: transaction.recipient,
+      },
+    });
+  });
+
+  it("should set gasLimit for ERC20 transactions when gas is estimated", async () => {
+    const mockTokenERC20 = getMockedERC20TokenCurrency();
+    const tokenAccount = getMockedTokenAccount(mockTokenERC20);
+    const accountWithToken = getMockedAccount({ subAccounts: [tokenAccount] });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Send,
+      subAccountId: tokenAccount.id,
+    });
+
+    const result = await prepareTransaction(accountWithToken, transaction);
+
+    expect(result).toMatchObject({
+      gasLimit: mockFeeEstimation.gas,
+    });
+  });
+
+  it("should use TokenTransfer operation type for HTS tokens", async () => {
+    const mockTokenHTS = getMockedHTSTokenCurrency();
+    const tokenAccount = getMockedTokenAccount(mockTokenHTS);
+    const accountWithToken = getMockedAccount({ subAccounts: [tokenAccount] });
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Send,
+      subAccountId: tokenAccount.id,
+    });
+
+    await prepareTransaction(accountWithToken, transaction);
+
+    expect(estimateFees).toHaveBeenCalledWith({
+      currency: accountWithToken.currency,
+      operationType: HEDERA_OPERATION_TYPES.TokenTransfer,
+    });
+  });
+
+  it("should use TokenAssociate operation type", async () => {
+    const mockTokenHTS = getMockedHTSTokenCurrency();
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
+      properties: {
+        token: mockTokenHTS,
+      },
+    });
+
+    await prepareTransaction(mockAccount, transaction);
+
+    expect(estimateFees).toHaveBeenCalledWith({
+      currency: mockAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.TokenAssociate,
+    });
+  });
+
+  it("should use CryptoTransfer operation type for native transfers", async () => {
+    const transaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.Send,
+      amount: new BigNumber(1000000),
+      recipient: "0.0.12345",
+    });
+
+    await prepareTransaction(mockAccount, transaction);
+
+    expect(estimateFees).toHaveBeenCalledWith({
+      currency: mockAccount.currency,
+      operationType: HEDERA_OPERATION_TYPES.CryptoTransfer,
+    });
+  });
 });

package/src/bridge/prepareTransaction.ts

@@ -1,8 +1,14 @@
+import BigNumber from "bignumber.js";
 import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
+import { getEnv } from "@ledgerhq/live-env";
 import type { AccountBridge } from "@ledgerhq/types-live";
-import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
+import {
+  HEDERA_OPERATION_TYPES,
+  HEDERA_TRANSACTION_MODES,
+  MAP_STAKING_MODE_TO_MEMO,
+} from "../constants";
 import { estimateFees } from "../logic/estimateFees";
-import { isTokenAssociateTransaction } from "../logic/utils";
+import { isTokenAssociateTransaction, isStakingTransaction } from "../logic/utils";
 import type { EstimateFeesParams, Transaction } from "../types";
 import { calculateAmount } from "./utils";
 
@@ -32,6 +38,8 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
     operationType = HEDERA_OPERATION_TYPES.TokenTransfer;
   } else if (isERC20TokenTransaction) {
     operationType = HEDERA_OPERATION_TYPES.ContractCall;
+  } else if (isStakingTransaction(transaction)) {
+    operationType = HEDERA_OPERATION_TYPES.CryptoUpdate;
   } else {
     operationType = HEDERA_OPERATION_TYPES.CryptoTransfer;
   }
@@ -79,5 +87,15 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
     transaction.gasLimit = estimatedFees.gas;
   }
 
+  if (isStakingTransaction(transaction)) {
+    transaction.memo = MAP_STAKING_MODE_TO_MEMO[transaction.mode];
+
+    // claiming staking rewards is triggered by sending 1 tinybar to staking reward account
+    if (transaction.mode === HEDERA_TRANSACTION_MODES.ClaimRewards) {
+      transaction.recipient = getEnv("HEDERA_CLAIM_REWARDS_RECIPIENT_ACCOUNT_ID");
+      transaction.amount = new BigNumber(1);
+    }
+  }
+
   return transaction;
 };