@ledgerhq/coin-hedera 1.15.0-nightly.20251206023719 → 1.15.0

package/src/logic/utils.test.ts

@@ -1,33 +1,19 @@
 import BigNumber from "bignumber.js";
 import { createHash } from "crypto";
-import { Transaction as SDKTransaction, TransactionId } from "@hashgraph/sdk";
-import type { AssetInfo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import { Transaction, TransactionId } from "@hashgraph/sdk";
+import type { AssetInfo } from "@ledgerhq/coin-framework/api/types";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { InvalidAddress } from "@ledgerhq/errors";
-import { getEnv, setEnv } from "@ledgerhq/live-env";
-import {
-  HEDERA_OPERATION_TYPES,
-  HEDERA_TRANSACTION_MODES,
-  SYNTHETIC_BLOCK_WINDOW_SECONDS,
-} from "../constants";
+import { 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,
@@ -49,36 +35,15 @@ 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();
   });
@@ -101,7 +66,7 @@ describe("logic utils", () => {
 
   describe("transaction serialization", () => {
     beforeEach(() => {
-      jest.spyOn(SDKTransaction, "fromBytes");
+      jest.spyOn(Transaction, "fromBytes");
     });
 
     afterEach(() => {
@@ -111,7 +76,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 SDKTransaction;
+      } as unknown as Transaction;
 
       const serialized = serializeTransaction(mockTransaction);
 
@@ -121,14 +86,14 @@ describe("logic utils", () => {
 
     it("should deserialize a hex string to a Transaction", () => {
       const mockTransaction = { id: "mock-transaction-id" };
-      (SDKTransaction.fromBytes as jest.Mock).mockReturnValue(mockTransaction);
+      (Transaction.fromBytes as jest.Mock).mockReturnValue(mockTransaction);
 
       const hexTransaction = "0a141e2832";
       const deserialized = deserializeTransaction(hexTransaction);
 
       const hexTransactionBuffer = Buffer.from([10, 20, 30, 40, 50]);
-      expect(SDKTransaction.fromBytes).toHaveBeenCalledTimes(1);
-      expect(SDKTransaction.fromBytes).toHaveBeenCalledWith(hexTransactionBuffer);
+      expect(Transaction.fromBytes).toHaveBeenCalledTimes(1);
+      expect(Transaction.fromBytes).toHaveBeenCalledWith(hexTransactionBuffer);
       expect(deserialized).toBe(mockTransaction);
     });
   });
@@ -177,75 +142,6 @@ 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");
@@ -351,7 +247,6 @@ describe("logic utils", () => {
         hederaResources: {
           maxAutomaticTokenAssociations: -1,
           isAutoTokenAssociationEnabled: true,
-          delegation: null,
         },
       });
 
@@ -496,22 +391,6 @@ 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");
@@ -718,237 +597,4 @@ 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,12 +12,10 @@ 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,
@@ -25,19 +23,13 @@ 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");
@@ -96,14 +88,6 @@ 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;
 };
 
@@ -138,10 +122,8 @@ export const getTransactionExplorer = (
   );
 };
 
-export const isTokenAssociateTransaction = (
-  tx: Transaction | null | undefined,
-): tx is TransactionTokenAssociate => {
-  return tx?.mode === HEDERA_TRANSACTION_MODES.TokenAssociate;
+export const isTokenAssociateTransaction = (tx: Transaction): tx is TransactionTokenAssociate => {
+  return tx.mode === HEDERA_TRANSACTION_MODES.TokenAssociate;
 };
 
 export const isAutoTokenAssociationEnabled = (account: AccountLike) => {
@@ -168,42 +150,6 @@ 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
@@ -266,15 +212,6 @@ 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 }] => {
@@ -283,7 +220,7 @@ export const safeParseAccountId = (
 
   try {
     const accountId = AccountId.fromString(address);
-    const checksum = getChecksum(address);
+    const checksum = EntityIdHelper.fromString(address).checksum ?? null;
 
     if (checksum) {
       const client = rpcClient.getInstance();
@@ -402,94 +339,3 @@ 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;
-};