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

package/src/logic/utils.test.ts

@@ -1,19 +1,33 @@
 import BigNumber from "bignumber.js";
 import { createHash } from "crypto";
-import { Transaction, TransactionId } from "@hashgraph/sdk";
-import type { AssetInfo } from "@ledgerhq/coin-framework/api/types";
+import { Transaction as SDKTransaction, TransactionId } from "@hashgraph/sdk";
+import type { AssetInfo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { InvalidAddress } from "@ledgerhq/errors";
-import { HEDERA_TRANSACTION_MODES, SYNTHETIC_BLOCK_WINDOW_SECONDS } from "../constants";
+import { getEnv, setEnv } from "@ledgerhq/live-env";
+import {
+  HEDERA_OPERATION_TYPES,
+  HEDERA_TRANSACTION_MODES,
+  SYNTHETIC_BLOCK_WINDOW_SECONDS,
+} from "../constants";
 import { HederaRecipientInvalidChecksum } from "../errors";
 import { apiClient } from "../network/api";
 import { rpcClient } from "../network/rpc";
+import * as preloadData from "../preload-data";
 import { getMockedOperation } from "../test/fixtures/operation.fixture";
 import {
   getMockedERC20TokenCurrency,
   getMockedHTSTokenCurrency,
 } from "../test/fixtures/currency.fixture";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
+import type {
+  HederaAccount,
+  HederaMemo,
+  HederaPreloadData,
+  HederaTxData,
+  HederaValidator,
+  Transaction,
+} from "../types";
 import {
   serializeSignature,
   deserializeSignature,
@@ -35,15 +49,36 @@ import {
   formatTransactionId,
   getTimestampRangeFromBlockHeight,
   getBlockHash,
+  isStakingTransaction,
+  extractCompanyFromNodeDescription,
+  sortValidators,
+  getValidatorFromAccount,
+  getDefaultValidator,
+  getDelegationStatus,
+  filterValidatorBySearchTerm,
+  hasSpecificIntentData,
+  getChecksum,
+  mapIntentToSDKOperation,
+  getOperationDetailsExtraFields,
 } from "./utils";
 
 jest.mock("../network/api");
 
 describe("logic utils", () => {
+  let oldStakingLedgerNodeIdEnv: number;
+
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
+  afterEach(() => {
+    setEnv("HEDERA_STAKING_LEDGER_NODE_ID", oldStakingLedgerNodeIdEnv);
+  });
+
+  beforeAll(() => {
+    oldStakingLedgerNodeIdEnv = getEnv("HEDERA_STAKING_LEDGER_NODE_ID");
+  });
+
   afterAll(() => {
     rpcClient._resetInstance();
   });
@@ -66,7 +101,7 @@ describe("logic utils", () => {
 
   describe("transaction serialization", () => {
     beforeEach(() => {
-      jest.spyOn(Transaction, "fromBytes");
+      jest.spyOn(SDKTransaction, "fromBytes");
     });
 
     afterEach(() => {
@@ -76,7 +111,7 @@ describe("logic utils", () => {
     it("should serialize a transaction to hex", () => {
       const mockTransaction = {
         toBytes: jest.fn().mockReturnValue(Buffer.from([10, 20, 30, 40, 50])),
-      } as unknown as Transaction;
+      } as unknown as SDKTransaction;
 
       const serialized = serializeTransaction(mockTransaction);
 
@@ -86,14 +121,14 @@ describe("logic utils", () => {
 
     it("should deserialize a hex string to a Transaction", () => {
       const mockTransaction = { id: "mock-transaction-id" };
-      (Transaction.fromBytes as jest.Mock).mockReturnValue(mockTransaction);
+      (SDKTransaction.fromBytes as jest.Mock).mockReturnValue(mockTransaction);
 
       const hexTransaction = "0a141e2832";
       const deserialized = deserializeTransaction(hexTransaction);
 
       const hexTransactionBuffer = Buffer.from([10, 20, 30, 40, 50]);
-      expect(Transaction.fromBytes).toHaveBeenCalledTimes(1);
-      expect(Transaction.fromBytes).toHaveBeenCalledWith(hexTransactionBuffer);
+      expect(SDKTransaction.fromBytes).toHaveBeenCalledTimes(1);
+      expect(SDKTransaction.fromBytes).toHaveBeenCalledWith(hexTransactionBuffer);
       expect(deserialized).toBe(mockTransaction);
     });
   });
@@ -142,6 +177,75 @@ describe("logic utils", () => {
     });
   });
 
+  describe("mapIntentToSDKOperation", () => {
+    it("should return TokenAssociate for TokenAssociate intent", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.TokenAssociate,
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.TokenAssociate);
+    });
+
+    it("should return TokenTransfer for Send intent with HTS asset", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.Send,
+        asset: { type: "hts", assetReference: "0.0.1234" },
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.TokenTransfer);
+    });
+
+    it("should return ContractCall for Send intent with ERC20 asset", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.Send,
+        asset: { type: "erc20", assetReference: "0x1234" },
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.ContractCall);
+    });
+
+    it("should return CryptoUpdate for Delegate intent", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.Delegate,
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.CryptoUpdate);
+    });
+
+    it("should return CryptoUpdate for Undelegate intent", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.Undelegate,
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.CryptoUpdate);
+    });
+
+    it("should return CryptoUpdate for Redelegate intent", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.Redelegate,
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.CryptoUpdate);
+    });
+
+    it("should return CryptoTransfer for Send intent with native asset", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.Send,
+        asset: { type: "native" },
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.CryptoTransfer);
+    });
+
+    it("should return CryptoTransfer for other intent types", () => {
+      const txIntent = {
+        type: HEDERA_TRANSACTION_MODES.ClaimRewards,
+      } as TransactionIntent;
+
+      expect(mapIntentToSDKOperation(txIntent)).toBe(HEDERA_OPERATION_TYPES.CryptoTransfer);
+    });
+  });
+
   describe("getMemoFromBase64", () => {
     it("decodes a simple base64 string", () => {
       expect(getMemoFromBase64("YnJkZw==")).toBe("brdg");
@@ -247,6 +351,7 @@ describe("logic utils", () => {
         hederaResources: {
           maxAutomaticTokenAssociations: -1,
           isAutoTokenAssociationEnabled: true,
+          delegation: null,
         },
       });
 
@@ -391,6 +496,22 @@ describe("logic utils", () => {
     });
   });
 
+  describe("getChecksum", () => {
+    it("should return correct checksum for valid account ID", () => {
+      const accountId = "0.0.9124531-xrxlv";
+      const checksum = getChecksum(accountId);
+
+      expect(checksum).toBe("xrxlv");
+    });
+
+    it("should return null for invalid account ID", () => {
+      const accountId = "invalid-account-id";
+      const checksum = getChecksum(accountId);
+
+      expect(checksum).toBeNull();
+    });
+  });
+
   describe("safeParseAccountId", () => {
     it("returns account id and no checksum for valid address without checksum", () => {
       const [error, result] = safeParseAccountId("0.0.9124531");
@@ -597,4 +718,237 @@ describe("logic utils", () => {
       expect(result.end).toMatch(/^\d+\.000000000$/);
     });
   });
+
+  describe("isStakingTransaction", () => {
+    it("returns correct value based on tx.mode", () => {
+      const stakingDelegateTx = { mode: HEDERA_TRANSACTION_MODES.Delegate } as Transaction;
+      const stakingUndelegateTx = { mode: HEDERA_TRANSACTION_MODES.Undelegate } as Transaction;
+      const stakingRedelegateTx = { mode: HEDERA_TRANSACTION_MODES.Redelegate } as Transaction;
+      const stakingClaimRewardsTx = { mode: HEDERA_TRANSACTION_MODES.ClaimRewards } as Transaction;
+      const transferTx = { recipient: "", amount: new BigNumber(1) } as Transaction;
+      const emptyTx = {} as Transaction;
+
+      expect(isStakingTransaction(stakingDelegateTx)).toBe(true);
+      expect(isStakingTransaction(stakingUndelegateTx)).toBe(true);
+      expect(isStakingTransaction(stakingRedelegateTx)).toBe(true);
+      expect(isStakingTransaction(stakingClaimRewardsTx)).toBe(true);
+      expect(isStakingTransaction(transferTx)).toBe(false);
+      expect(isStakingTransaction(emptyTx)).toBe(false);
+    });
+
+    it("returns false for undefined or null transactions", () => {
+      expect(isStakingTransaction(undefined as unknown as Transaction)).toBe(false);
+      expect(isStakingTransaction(null as unknown as Transaction)).toBe(false);
+    });
+  });
+
+  describe("extractCompanyFromNodeDescription", () => {
+    it("extracts company name from description", () => {
+      expect(extractCompanyFromNodeDescription("Hosted by Ledger | Paris, France")).toBe("Ledger");
+      expect(extractCompanyFromNodeDescription("Hosted by LG | Seoul, South Korea")).toBe("LG");
+      expect(extractCompanyFromNodeDescription("TestCompany | something else")).toBe("TestCompany");
+      expect(extractCompanyFromNodeDescription("NoSeparator ")).toBe("NoSeparator");
+    });
+  });
+
+  describe("sortValidators", () => {
+    it("sorts validators by active stake DESC, Ledger node first if set", () => {
+      setEnv("HEDERA_STAKING_LEDGER_NODE_ID", 2);
+
+      const validators = [
+        { nodeId: 3, activeStake: new BigNumber(1000) },
+        { nodeId: 2, activeStake: new BigNumber(2000) },
+        { nodeId: 1, activeStake: new BigNumber(3000) },
+      ] as HederaValidator[];
+
+      const sorted = sortValidators(validators);
+
+      expect(sorted[0].nodeId).toBe(2);
+      expect(sorted[1].nodeId).toBe(1);
+      expect(sorted[2].nodeId).toBe(3);
+    });
+  });
+
+  describe("getValidatorFromAccount", () => {
+    const mockValidator = { nodeId: 1 };
+    const mockPreload = { validators: [mockValidator] } as HederaPreloadData;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+
+      jest.spyOn(preloadData, "getCurrentHederaPreloadData").mockReturnValueOnce(mockPreload);
+    });
+
+    it("returns validator matching delegation nodeId", () => {
+      const mockAccount = {
+        currency: "hedera",
+        hederaResources: { delegation: { nodeId: 1 } },
+      } as unknown as HederaAccount;
+
+      expect(getValidatorFromAccount(mockAccount)).toEqual(mockValidator);
+    });
+
+    it("returns null if no delegation", () => {
+      const mockAccount = {
+        currency: "hedera",
+        hederaResources: {},
+      } as unknown as HederaAccount;
+
+      expect(getValidatorFromAccount(mockAccount)).toBeNull();
+    });
+  });
+
+  describe("getDefaultValidator", () => {
+    const mockValidators = [
+      { nodeId: 1, activeStake: new BigNumber(2000) },
+      { nodeId: 2, activeStake: new BigNumber(1000) },
+      { nodeId: 3, activeStake: new BigNumber(10000) },
+    ] as HederaValidator[];
+
+    it("returns Ledger validator if present", () => {
+      setEnv("HEDERA_STAKING_LEDGER_NODE_ID", 2);
+      expect(getDefaultValidator(mockValidators)?.nodeId).toBe(2);
+    });
+
+    it("returns null if no Ledger validator is present", () => {
+      expect(getDefaultValidator([])).toBeNull();
+    });
+  });
+
+  describe("getDelegationStatus", () => {
+    const mockValidator = { address: "0.0.3", overstaked: false } as HederaValidator;
+    const mockOverstakedValidator = { address: "0.0.3", overstaked: true } as HederaValidator;
+
+    it("returns inactive if validator or validator's address is missing", () => {
+      expect(getDelegationStatus(null)).toBe("inactive");
+      expect(getDelegationStatus({ address: "" } as any)).toBe("inactive");
+    });
+
+    it("returns overstaked if validator.overstaked is true", () => {
+      expect(getDelegationStatus(mockOverstakedValidator)).toBe("overstaked");
+    });
+
+    it("returns active otherwise", () => {
+      expect(getDelegationStatus(mockValidator)).toBe("active");
+    });
+  });
+
+  describe("filterValidatorBySearchTerm", () => {
+    const mockValidator: HederaValidator = {
+      nodeId: 123,
+      name: "Validator Test",
+      address: "0.0.456",
+      addressChecksum: "abcde",
+      minStake: new BigNumber(0),
+      maxStake: new BigNumber(0),
+      activeStake: new BigNumber(0),
+      activeStakePercentage: new BigNumber(0),
+      overstaked: false,
+    };
+
+    it("should match by nodeId", () => {
+      expect(filterValidatorBySearchTerm(mockValidator, "123")).toBe(true);
+    });
+
+    it("should match by name with case insensitivity", () => {
+      expect(filterValidatorBySearchTerm(mockValidator, "validator")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "VALIDATOR")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "test")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "unknown")).toBe(false);
+    });
+
+    it("should match by address", () => {
+      expect(filterValidatorBySearchTerm(mockValidator, "0.0.456")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "456")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "789")).toBe(false);
+    });
+
+    it("should match by address with checksum", () => {
+      expect(filterValidatorBySearchTerm(mockValidator, "0.0.456-abcde")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "abcde")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "ABC")).toBe(true);
+    });
+
+    it("should handle validator without checksum", () => {
+      const validatorWithoutChecksum = { ...mockValidator, addressChecksum: null };
+      expect(filterValidatorBySearchTerm(validatorWithoutChecksum, "0.0.456")).toBe(true);
+      expect(filterValidatorBySearchTerm(validatorWithoutChecksum, "abcde")).toBe(false);
+    });
+
+    it("should handle empty search term", () => {
+      expect(filterValidatorBySearchTerm(mockValidator, "")).toBe(true);
+    });
+
+    it("should handle partial matches", () => {
+      expect(filterValidatorBySearchTerm(mockValidator, "valid")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "0.0")).toBe(true);
+      expect(filterValidatorBySearchTerm(mockValidator, "12")).toBe(true);
+    });
+  });
+
+  describe("hasSpecificIntentData", () => {
+    it("should return true when txIntent has data matching expected type", () => {
+      const stakingTxIntent = {
+        data: { type: "staking" as const },
+      } as TransactionIntent<HederaMemo, HederaTxData>;
+      const erc20TxIntent = {
+        data: { type: "erc20" as const },
+      } as TransactionIntent<HederaMemo, HederaTxData>;
+
+      expect(hasSpecificIntentData(stakingTxIntent, "staking")).toBe(true);
+      expect(hasSpecificIntentData(erc20TxIntent, "erc20")).toBe(true);
+    });
+
+    it("should return false when txIntent has invalid data", () => {
+      const txIntentNoData = {} as TransactionIntent<HederaMemo, HederaTxData>;
+      const txIntentUnknown = {
+        data: { type: "unknown" as const },
+      } as unknown as TransactionIntent<HederaMemo, HederaTxData>;
+
+      expect(hasSpecificIntentData(txIntentUnknown, "erc20")).toBe(false);
+      expect(hasSpecificIntentData(txIntentNoData, "erc20")).toBe(false);
+    });
+  });
+
+  describe("getOperationDetailsExtraFields", () => {
+    it("should return empty array when no fields are present", () => {
+      const result = getOperationDetailsExtraFields({});
+
+      expect(result).toEqual([]);
+    });
+
+    it("should handle zero values correctly", () => {
+      const result = getOperationDetailsExtraFields({
+        gasConsumed: 0,
+        targetStakingNodeId: 0,
+      });
+
+      expect(result).toEqual([
+        { key: "targetStakingNodeId", value: "0" },
+        { key: "gasConsumed", value: "0" },
+      ]);
+    });
+
+    it("should return all fields when all are present", () => {
+      const result = getOperationDetailsExtraFields({
+        memo: "complete",
+        associatedTokenId: "123",
+        targetStakingNodeId: 5,
+        previousStakingNodeId: 3,
+        gasConsumed: 1000,
+        gasUsed: 950,
+        gasLimit: 2000,
+      });
+
+      expect(result).toEqual([
+        { key: "memo", value: "complete" },
+        { key: "associatedTokenId", value: "123" },
+        { key: "targetStakingNodeId", value: "5" },
+        { key: "previousStakingNodeId", value: "3" },
+        { key: "gasConsumed", value: "1000" },
+        { key: "gasUsed", value: "950" },
+        { key: "gasLimit", value: "2000" },
+      ]);
+    });
+  });
 });

package/src/logic/utils.ts

@@ -12,10 +12,12 @@ import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/fiats";
 import cvsApi from "@ledgerhq/live-countervalues/api/index";
 import { InvalidAddress } from "@ledgerhq/errors";
+import { getEnv } from "@ledgerhq/live-env";
 import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
 import type { Currency, ExplorerView, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { AccountLike, Operation as LiveOperation } from "@ledgerhq/types-live";
 import {
+  HEDERA_DELEGATION_STATUS,
   HEDERA_OPERATION_TYPES,
   HEDERA_TRANSACTION_MODES,
   SYNTHETIC_BLOCK_WINDOW_SECONDS,
@@ -23,13 +25,19 @@ import {
 import { apiClient } from "../network/api";
 import type {
   HederaAccount,
+  HederaMemo,
   HederaOperationExtra,
+  HederaTxData,
+  HederaValidator,
+  OperationDetailsExtraField,
   Transaction,
+  TransactionStaking,
   TransactionStatus,
   TransactionTokenAssociate,
 } from "../types";
 import { rpcClient } from "../network/rpc";
 import { HederaRecipientInvalidChecksum } from "../errors";
+import { getCurrentHederaPreloadData } from "../preload-data";
 
 export const serializeSignature = (signature: Uint8Array) => {
   return Buffer.from(signature).toString("base64");
@@ -88,6 +96,14 @@ export const mapIntentToSDKOperation = (txIntent: TransactionIntent) => {
     return HEDERA_OPERATION_TYPES.ContractCall;
   }
 
+  if (
+    txIntent.type === HEDERA_TRANSACTION_MODES.Delegate ||
+    txIntent.type === HEDERA_TRANSACTION_MODES.Undelegate ||
+    txIntent.type === HEDERA_TRANSACTION_MODES.Redelegate
+  ) {
+    return HEDERA_OPERATION_TYPES.CryptoUpdate;
+  }
+
   return HEDERA_OPERATION_TYPES.CryptoTransfer;
 };
 
@@ -122,8 +138,10 @@ export const getTransactionExplorer = (
   );
 };
 
-export const isTokenAssociateTransaction = (tx: Transaction): tx is TransactionTokenAssociate => {
-  return tx.mode === HEDERA_TRANSACTION_MODES.TokenAssociate;
+export const isTokenAssociateTransaction = (
+  tx: Transaction | null | undefined,
+): tx is TransactionTokenAssociate => {
+  return tx?.mode === HEDERA_TRANSACTION_MODES.TokenAssociate;
 };
 
 export const isAutoTokenAssociationEnabled = (account: AccountLike) => {
@@ -150,6 +168,42 @@ export const isValidExtra = (extra: unknown): extra is HederaOperationExtra => {
   return !!extra && typeof extra === "object" && !Array.isArray(extra);
 };
 
+export const getOperationDetailsExtraFields = (
+  extra: HederaOperationExtra,
+): OperationDetailsExtraField[] => {
+  const fields: OperationDetailsExtraField[] = [];
+
+  if (typeof extra.memo === "string") {
+    fields.push({ key: "memo", value: extra.memo });
+  }
+
+  if (typeof extra.associatedTokenId === "string") {
+    fields.push({ key: "associatedTokenId", value: extra.associatedTokenId });
+  }
+
+  if (typeof extra.targetStakingNodeId === "number") {
+    fields.push({ key: "targetStakingNodeId", value: extra.targetStakingNodeId.toString() });
+  }
+
+  if (typeof extra.previousStakingNodeId === "number") {
+    fields.push({ key: "previousStakingNodeId", value: extra.previousStakingNodeId.toString() });
+  }
+
+  if (typeof extra.gasConsumed === "number") {
+    fields.push({ key: "gasConsumed", value: extra.gasConsumed.toString() });
+  }
+
+  if (typeof extra.gasUsed === "number") {
+    fields.push({ key: "gasUsed", value: extra.gasUsed.toString() });
+  }
+
+  if (typeof extra.gasLimit === "number") {
+    fields.push({ key: "gasLimit", value: extra.gasLimit.toString() });
+  }
+
+  return fields;
+};
+
 // disables the "Continue" button in the Send modal's Recipient step during token transfers if:
 // - the recipient is not associated with the token
 // - the association status can't be verified
@@ -212,6 +266,15 @@ export const checkAccountTokenAssociationStatus = makeLRUCache(
   seconds(30),
 );
 
+export const getChecksum = (accountId: string): string | null => {
+  try {
+    const entityId = EntityIdHelper.fromString(accountId);
+    return entityId.checksum ?? null;
+  } catch {
+    return null;
+  }
+};
+
 export const safeParseAccountId = (
   address: string,
 ): [Error, null] | [null, { accountId: string; checksum: string | null }] => {
@@ -220,7 +283,7 @@ export const safeParseAccountId = (
 
   try {
     const accountId = AccountId.fromString(address);
-    const checksum = EntityIdHelper.fromString(address).checksum ?? null;
+    const checksum = getChecksum(address);
 
     if (checksum) {
       const client = rpcClient.getInstance();
@@ -237,7 +300,7 @@ export const safeParseAccountId = (
     };
 
     return [null, result];
-  } catch (err) {
+  } catch {
     return [new InvalidAddress("", { currencyName }), null];
   }
 };
@@ -339,3 +402,94 @@ export const fromEVMAddress = (evmAddress: string, shard = 0, realm = 0): string
     return null;
   }
 };
+
+export const extractCompanyFromNodeDescription = (description: string): string => {
+  return description
+    .split("|")[0]
+    .replace(/hosted by/i, "")
+    .replace(/hosted for/i, "")
+    .trim();
+};
+
+export const sortValidators = (validators: HederaValidator[]): HederaValidator[] => {
+  const ledgerNodeId = getEnv("HEDERA_STAKING_LEDGER_NODE_ID");
+
+  // sort validators by active stake in DESC order, with Ledger node first if it exists
+  return [...validators].sort((a, b) => {
+    if (typeof ledgerNodeId === "number") {
+      if (a.nodeId === ledgerNodeId) return -1;
+      if (b.nodeId === ledgerNodeId) return 1;
+    }
+
+    return b.activeStake.toNumber() - a.activeStake.toNumber();
+  });
+};
+
+export const filterValidatorBySearchTerm = (
+  validator: HederaValidator,
+  search: string,
+): boolean => {
+  const lowercaseSearch = search.toLowerCase();
+  const addressWithChecksum = validator.addressChecksum
+    ? `${validator.address}-${validator.addressChecksum}`
+    : validator.address;
+
+  return (
+    validator.nodeId.toString().includes(lowercaseSearch) ||
+    validator.name.toLowerCase().includes(lowercaseSearch) ||
+    addressWithChecksum.toLowerCase().includes(lowercaseSearch)
+  );
+};
+
+export const getValidatorFromAccount = (account: HederaAccount): HederaValidator | null => {
+  const { delegation } = account.hederaResources ?? {};
+
+  if (!delegation) {
+    return null;
+  }
+
+  const validators = getCurrentHederaPreloadData(account.currency);
+  const validator = validators.validators.find(v => v.nodeId === delegation.nodeId) ?? null;
+
+  return validator;
+};
+
+export const getDefaultValidator = (validators: HederaValidator[]): HederaValidator | null => {
+  const ledgerNodeId = getEnv("HEDERA_STAKING_LEDGER_NODE_ID");
+
+  return validators.find(v => v.nodeId === ledgerNodeId) ?? null;
+};
+
+export const getDelegationStatus = (
+  validator: HederaValidator | null,
+): HEDERA_DELEGATION_STATUS => {
+  if (!validator?.address) {
+    return HEDERA_DELEGATION_STATUS.Inactive;
+  }
+
+  if (validator.overstaked) {
+    return HEDERA_DELEGATION_STATUS.Overstaked;
+  }
+
+  return HEDERA_DELEGATION_STATUS.Active;
+};
+
+export const isStakingTransaction = (
+  tx: Transaction | null | undefined,
+): tx is TransactionStaking => {
+  if (!tx) return false;
+
+  return (
+    tx.mode === HEDERA_TRANSACTION_MODES.Delegate ||
+    tx.mode === HEDERA_TRANSACTION_MODES.Undelegate ||
+    tx.mode === HEDERA_TRANSACTION_MODES.Redelegate ||
+    tx.mode === HEDERA_TRANSACTION_MODES.ClaimRewards
+  );
+};
+
+export const hasSpecificIntentData = <Type extends "staking" | "erc20">(
+  txIntent: TransactionIntent<HederaMemo, HederaTxData>,
+  expectedType: Type,
+): txIntent is Extract<TransactionIntent<HederaMemo, HederaTxData>, { data: { type: Type } }> => {
+  return "data" in txIntent && txIntent.data.type === expectedType;
+};