@ledgerhq/coin-hedera 1.15.0-nightly.20251209144712 → 1.15.1

package/src/bridge/getTransactionStatus.test.ts

@@ -4,24 +4,18 @@ 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 {
@@ -29,28 +23,26 @@ import {
   getMockedHTSTokenCurrency,
 } from "../test/fixtures/currency.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
-import type { EstimateFeesResult, HederaPreloadData } from "../types";
+import type { EstimateFeesResult } 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(estimateFees, "estimateFees").mockResolvedValueOnce(mockedEstimatedFee);
     jest.spyOn(logicUtils, "getCurrencyToUSDRate").mockResolvedValueOnce(mockedUsdRate);
-    jest.spyOn(preloadData, "getCurrentHederaPreloadData").mockReturnValueOnce(mockPreload);
+    jest.spyOn(estimateFees, "estimateFees").mockResolvedValueOnce(mockedEstimatedFee);
   });
 
   afterAll(() => {
     rpcClient._resetInstance();
   });
 
-  it("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
+  test("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(1000) });
     const mockedTransaction = getMockedTransaction({
       recipient: validRecipientAddress,
@@ -65,7 +57,7 @@ describe("getTransactionStatus", () => {
     expect(result.totalSpent.isGreaterThan(100)).toBe(true);
   });
 
-  it("hts token transfer with valid recipient and sufficient balance completes successfully", async () => {
+  test("hts token transfer with valid recipient and sufficient balance completes successfully", async () => {
     jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(true);
 
     const tokenCurrency = getMockedHTSTokenCurrency();
@@ -84,7 +76,7 @@ describe("getTransactionStatus", () => {
     expect(result.amount).toEqual(new BigNumber(200));
   });
 
-  it("erc20 token transfer with valid recipient and sufficient balance completes successfully", async () => {
+  test("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] });
@@ -103,7 +95,7 @@ describe("getTransactionStatus", () => {
     expect(result.amount).toEqual(new BigNumber(200));
   });
 
-  it("token associate transaction with sufficient USD worth completes successfully", async () => {
+  test("token associate transaction with sufficient USD worth completes successfully", async () => {
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
@@ -122,7 +114,7 @@ describe("getTransactionStatus", () => {
     expect(result.estimatedFees).toEqual(mockedEstimatedFee.tinybars);
   });
 
-  it("recipient with checksum is supported", async () => {
+  test("recipient with checksum is supported", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(1000) });
     const mockedTransaction = getMockedTransaction({
       recipient: validRecipientAddressWithChecksum,
@@ -135,25 +127,22 @@ describe("getTransactionStatus", () => {
     expect(result.warnings).toEqual({});
   });
 
-  it("adds error for invalid recipient address", async () => {
+  test("adds error for invalid recipient address", async () => {
     const mockedAccount = getMockedAccount();
 
-    const txWithInvalidAddress1 = getMockedTransaction({ recipient: "" });
-    const txWithInvalidAddress2 = getMockedTransaction({ recipient: "invalid_address" });
+    const txWithInvalidAddress = getMockedTransaction({ recipient: "invalid_address" });
     const txWithInvalidAddressChecksum = getMockedTransaction({ recipient: "0.0.9124531-invld" });
 
-    const [result1, result2, result3] = await Promise.all([
-      getTransactionStatus(mockedAccount, txWithInvalidAddress1),
-      getTransactionStatus(mockedAccount, txWithInvalidAddress2),
+    const [result1, result2] = await Promise.all([
+      getTransactionStatus(mockedAccount, txWithInvalidAddress),
       getTransactionStatus(mockedAccount, txWithInvalidAddressChecksum),
     ]);
 
-    expect(result1.errors.recipient).toBeInstanceOf(RecipientRequired);
-    expect(result2.errors.recipient).toBeInstanceOf(InvalidAddress);
-    expect(result3.errors.recipient).toBeInstanceOf(HederaRecipientInvalidChecksum);
+    expect(result1.errors.recipient).toBeInstanceOf(InvalidAddress);
+    expect(result2.errors.recipient).toBeInstanceOf(HederaRecipientInvalidChecksum);
   });
 
-  it("adds error for self transfers", async () => {
+  test("adds error for self transfers", async () => {
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
       recipient: mockedAccount.freshAddress,
@@ -164,7 +153,7 @@ describe("getTransactionStatus", () => {
     expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
   });
 
-  it("adds error during coin transfer with insufficient balance", async () => {
+  test("adds error during coin transfer with insufficient balance", async () => {
     const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
     const mockedTransaction = getMockedTransaction({
       amount: new BigNumber(100),
@@ -176,7 +165,7 @@ describe("getTransactionStatus", () => {
     expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
   });
 
-  it("adds error if USD balance is too low for token association", async () => {
+  test("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({
@@ -193,7 +182,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  it("adds warning during token transfer if recipient has no token associated", async () => {
+  test("adds warning during token transfer if recipient has no token associated", async () => {
     jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(false);
 
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
@@ -211,7 +200,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  it("adds evm address verification warning during ERC20 token transfer", async () => {
+  test("adds evm address verification warning during ERC20 token transfer", async () => {
     const mockedTokenCurrency = getMockedERC20TokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
     const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
@@ -227,7 +216,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  it("adds warning if token association status can't be verified", async () => {
+  test("adds warning if token association status can't be verified", async () => {
     jest
       .spyOn(logicUtils, "checkAccountTokenAssociationStatus")
       .mockRejectedValueOnce(new HederaRecipientTokenAssociationUnverified());
@@ -247,7 +236,7 @@ describe("getTransactionStatus", () => {
     );
   });
 
-  it("adds error during token transfer with insufficient balance", async () => {
+  test("adds error during token transfer with insufficient balance", async () => {
     const mockedTokenCurrency = getMockedHTSTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency, {
       balance: new BigNumber(0),
@@ -264,7 +253,7 @@ describe("getTransactionStatus", () => {
     expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
   });
 
-  it("adds error if amount is zero and useAllAmount is false", async () => {
+  test("adds error if amount is zero and useAllAmount is false", async () => {
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
       recipient: validRecipientAddress,
@@ -276,163 +265,4 @@ 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,11 +1,9 @@
 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";
@@ -16,9 +14,6 @@ import {
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
   HederaRecipientEvmAddressVerificationRequired,
-  HederaInvalidStakingNodeIdError,
-  HederaRedundantStakingNodeIdError,
-  HederaNoStakingRewardsError,
 } from "../errors";
 import { estimateFees } from "../logic/estimateFees";
 import {
@@ -27,15 +22,8 @@ import {
   getCurrencyToUSDRate,
   checkAccountTokenAssociationStatus,
   safeParseAccountId,
-  isStakingTransaction,
 } from "../logic/utils";
-import { getCurrentHederaPreloadData } from "../preload-data";
-import type {
-  HederaAccount,
-  Transaction,
-  TransactionStatus,
-  TransactionTokenAssociate,
-} from "../types";
+import type { Transaction, TransactionStatus, TransactionTokenAssociate } from "../types";
 import { calculateAmount } from "./utils";
 
 type Errors = Record<string, Error>;
@@ -253,66 +241,6 @@ 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,
@@ -330,8 +258,6 @@ 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,7 +13,6 @@ 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";
@@ -30,9 +29,8 @@ function buildCurrencyBridge(signerContext: SignerContext<HederaSigner>): Curren
   });
 
   return {
-    preload,
-    hydrate,
-    getPreloadStrategy,
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
     scanAccounts,
   };
 }

package/src/bridge/prepareTransaction.test.ts

@@ -1,136 +1,32 @@
 import BigNumber from "bignumber.js";
 import { estimateFees } from "../logic/estimateFees";
 import { prepareTransaction } from "./prepareTransaction";
-import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
+import { getMockedAccount } 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),
-    gas: new BigNumber(5),
-  };
-  const mockCalculatedAmount = {
-    amount: new BigNumber(100),
-    totalSpent: new BigNumber(100),
-  };
+  const mockFeeEstimation: EstimateFeesResult = { tinybars: new BigNumber(10) };
 
   beforeEach(() => {
     jest.clearAllMocks();
 
     (estimateFees as jest.Mock).mockResolvedValue(mockFeeEstimation);
-    jest.spyOn(utils, "calculateAmount").mockResolvedValue(mockCalculatedAmount);
+    jest
+      .spyOn(utils, "calculateAmount")
+      .mockResolvedValue(
+        Promise.resolve({ amount: new BigNumber(100), totalSpent: new BigNumber(100) }),
+      );
   });
 
-  it("should set amount and maxFee from utils", async () => {
+  test("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,14 +1,8 @@
-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,
-  MAP_STAKING_MODE_TO_MEMO,
-} from "../constants";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
 import { estimateFees } from "../logic/estimateFees";
-import { isTokenAssociateTransaction, isStakingTransaction } from "../logic/utils";
+import { isTokenAssociateTransaction } from "../logic/utils";
 import type { EstimateFeesParams, Transaction } from "../types";
 import { calculateAmount } from "./utils";
 
@@ -38,8 +32,6 @@ 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;
   }
@@ -87,15 +79,5 @@ 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;
 };