@ledgerhq/coin-hedera 1.16.0-nightly.20251212024049 → 1.16.0-nightly.20251215100948

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/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",
+};

package/src/deviceTransactionConfig.test.ts

@@ -1,14 +1,12 @@
 import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
 import { HEDERA_TRANSACTION_MODES } from "./constants";
 import getDeviceTransactionConfig from "./deviceTransactionConfig";
-import type { Transaction, TransactionStatus } from "./types";
+import type { TransactionStatus } from "./types";
+import { getMockedAccount } from "./test/fixtures/account.fixture";
+import { getMockedTransaction } from "./test/fixtures/transaction.fixture";
 
 describe("getDeviceTransactionConfig", () => {
-  const mockAccount = {
-    id: "mock-account-id",
-    currency: { id: "hedera" },
-  } as Account;
+  const mockAccount = getMockedAccount({ id: "mock-account-id" });
 
   const createMockStatus = (estimatedFees: BigNumber): TransactionStatus => ({
     errors: {},
@@ -20,13 +18,11 @@ describe("getDeviceTransactionConfig", () => {
 
   describe("staking transactions", () => {
     it("should return correct fields for ClaimRewards transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.ClaimRewards,
         amount: new BigNumber(0),
-        recipient: "",
         memo: "Claiming rewards",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -55,15 +51,48 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should return correct fields for Delegate transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Delegate,
         amount: new BigNumber(0),
-        recipient: "",
         properties: {
           stakingNodeId: 10,
         },
-      } as Transaction;
+      });
+
+      const status = createMockStatus(new BigNumber(100000));
+
+      const fields = await getDeviceTransactionConfig({
+        account: mockAccount,
+        transaction,
+        status,
+      });
+
+      expect(fields).toEqual([
+        {
+          type: "text",
+          label: "Method",
+          value: "Delegate",
+        },
+        {
+          label: "Fees",
+          type: "fees",
+        },
+        {
+          type: "text",
+          label: "Staked Node ID",
+          value: "10",
+        },
+      ]);
+    });
+
+    it("should return correct fields for Redelegate transaction", async () => {
+      const transaction = getMockedTransaction({
+        mode: HEDERA_TRANSACTION_MODES.Redelegate,
+        amount: new BigNumber(0),
+        properties: {
+          stakingNodeId: 10,
+        },
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -77,7 +106,7 @@ describe("getDeviceTransactionConfig", () => {
         {
           type: "text",
           label: "Method",
-          value: "Update Account",
+          value: "Redelegate",
         },
         {
           label: "Fees",
@@ -92,13 +121,10 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should not include staking node ID if not provided", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Undelegate,
         amount: new BigNumber(0),
-        recipient: "",
-        properties: {},
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -112,7 +138,7 @@ describe("getDeviceTransactionConfig", () => {
         {
           type: "text",
           label: "Method",
-          value: "Update Account",
+          value: "Undelegate",
         },
         {
           label: "Fees",
@@ -124,14 +150,11 @@ describe("getDeviceTransactionConfig", () => {
 
   describe("token associate transactions", () => {
     it("should return correct fields for TokenAssociate transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
-        amount: new BigNumber(0),
-        recipient: "",
         subAccountId: "token-account-id",
         memo: "Associating token",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(50000));
 
@@ -160,13 +183,10 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should not include fees if they are zero", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
-        amount: new BigNumber(0),
-        recipient: "",
         subAccountId: "token-account-id",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(0));
 
@@ -188,14 +208,13 @@ describe("getDeviceTransactionConfig", () => {
 
   describe("regular transfer transactions", () => {
     it("should return correct fields for regular Send transaction", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(1000000),
         recipient: "0.0.12345",
         useAllAmount: false,
         memo: "Payment",
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -228,13 +247,12 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should show 'Transfer All' method when useAllAmount is true", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(0),
         recipient: "0.0.12345",
         useAllAmount: true,
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -252,14 +270,13 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should include gas limit for Send transactions with gasLimit", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(1000000),
         recipient: "0.0.12345",
         useAllAmount: false,
         gasLimit: new BigNumber(300000),
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 
@@ -292,13 +309,12 @@ describe("getDeviceTransactionConfig", () => {
     });
 
     it("should not include memo if not provided", async () => {
-      const transaction = {
-        family: "hedera",
+      const transaction = getMockedTransaction({
         mode: HEDERA_TRANSACTION_MODES.Send,
         amount: new BigNumber(1000000),
         recipient: "0.0.12345",
         useAllAmount: false,
-      } as Transaction;
+      });
 
       const status = createMockStatus(new BigNumber(100000));
 

package/src/deviceTransactionConfig.ts

@@ -1,6 +1,6 @@
 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 { HEDERA_TRANSACTION_MODES, MAP_STAKING_MODE_TO_METHOD } from "./constants";
 import { isTokenAssociateTransaction, isStakingTransaction } from "./logic/utils";
 import type { Transaction, TransactionStatus } from "./types";
 
@@ -19,10 +19,7 @@ async function getDeviceTransactionConfig({
     fields.push({
       type: "text",
       label: "Method",
-      value:
-        transaction.mode === HEDERA_TRANSACTION_MODES.ClaimRewards
-          ? "Claim Rewards"
-          : "Update Account",
+      value: MAP_STAKING_MODE_TO_METHOD[transaction.mode],
     });
 
     if (!estimatedFees.isZero()) {