@swapkit/helpers 4.5.8 → 4.12.3

package/src/types/quotes.ts

@@ -1,174 +0,0 @@
-export enum ErrorCode {
-  unknownError = "unknownError",
-  test_error = "test_error",
-  providerDetailsError = "providerDetailsError",
-  blockHeaderNotFound = "blockHeaderNotFound",
-  blockHashNotFoundAtHeight = "blockHashNotFoundAtHeight",
-  blockHashNotFoundAtHash = "blockHashNotFoundAtHash",
-  txHashMissing = "txHashMissing",
-  assetValueMissingInfo = "assetValueMissingInfo",
-  invalidAsset = "invalidAsset",
-  blockIsRequired = "blockIsRequired",
-  currentBlockHeaderNotFound = "currentBlockHeaderNotFound",
-  failedToRetrieveBalance = "failedToRetrieveBalance",
-  failedToRetrieveBlock = "failedToRetrieveBlock",
-  failedToRetrieveFees = "failedToRetrieveFees",
-  notImplementedBCH = "notImplementedBCH",
-  notImplementedDoge = "notImplementedDoge",
-  noPoolsFound = "noPoolsFound",
-  noVaultsFound = "noVaultsFound",
-  noTxFound = "noTxFound",
-  noInputCoinFound = "noInputCoinFound",
-  noBlockDataFound = "noBlockDataFound",
-  multipleCosmosMessages = "multipleCosmosMessages",
-  heightOrHashNotProvided = "heightOrHashNotProvided",
-  unknownDenom = "unknownDenom",
-  invalidBlockHeight = "invalidBlockHeight",
-  timestampExtrinsicNoArgumentsForBlock = "timestampExtrinsicNoArgumentsForBlock",
-  timestampExtrinsicNoTimestampForBlock = "timestampExtrinsicNoTimestampForBlock",
-  noTimestampExtrinsicForHash = "noTimestampExtrinsicForHash",
-  timestampExtrinsicNoArgumentsForHash = "timestampExtrinsicNoArgumentsForHash",
-  txMemoUndefined = "txMemoUndefined",
-  txMemoIncorrect = "txMemoIncorrect",
-  txTypeNotFound = "txTypeNotFound",
-  txNoMessage = "txNoMessage",
-  txNotFound = "txNotFound",
-  txReceiptNotFound = "txReceiptNotFound",
-  txParsingError = "txParsingError",
-  txLogsParsingError = "txLogsParsingError",
-  blockNotFound = "blockNotFound",
-  balanceNotFound = "balanceNotFound",
-  configError = "configError",
-  synthSwapDisallowed = "synthSwapDisallowed",
-  providerQuoteTimeout = "providerQuoteTimeout",
-  noQuoteResponse = "noQuoteResponse",
-  noPoolAssetsFound = "noPoolAssetsFound",
-  noThorchainPools = "noThorchainPools",
-  noMayachainPools = "noMayachainPools",
-  noThorchainNetworkInfo = "noThorchainNetworkInfo",
-  invalidAffiliateFee = "invalidAffiliateFee",
-  invalidBuyAssetAddress = "invalidBuyAssetAddress",
-  invalidSellAssetAddress = "invalidSellAssetAddress",
-  invalidSourceAddress = "invalidSourceAddress",
-  invalidDestinationAddress = "invalidDestinationAddress",
-  sourceAddressIsSmartContract = "sourceAddressIsSmartContract",
-  destinationAddressIsSmartContract = "destinationAddressIsSmartContract",
-  invalidChainId = "invalidChainId",
-  unsupportedChainId = "unsupportedChainId",
-  unsupportedEVMChainId = "unsupportedEVMChainId",
-  unsupportedMethod = "unsupportedMethod",
-  unsupportedProvider = "unsupportedProvider",
-  invalidParamsForMethod = "invalidParamsForMethod",
-  unsupportedAdapter = "unsupportedAdapter",
-  noWhitelistTokens = "noWhitelistTokens",
-  failedFetchGasPrice = "failedFetchGasPrice",
-  failedToCreateDepositChannel = "failedToCreateDepositChannel",
-  noProviderDetailsFound = "noProviderDetailsFound",
-  noTokenListsFound = "noTokenListsFound",
-  tokenNotFound = "tokenNotFound",
-  tokenPriceNotFound = "tokenPriceNotFound",
-  tokenPriceFailedToUpdate = "tokenPriceFailedToUpdate",
-  swapAmountTooSmall = "swapAmountTooSmall",
-  legsArrayIsEmpty = "legsArrayIsEmpty",
-  failedToFetchQuoteForLeg = "failedToFetchQuoteForLeg",
-  noBlockHeaderFound = "noBlockHeaderFound",
-  failedToSimulateSwap = "failedToSimulateSwap",
-  addressScreeningFailed = "addressScreeningFailed",
-  noLiquidtyProvidersFound = "noLiquidtyProvidersFound",
-  insufficientLiquidity = "insufficientLiquidity",
-  noInboundDataFound = "noInbounDataFound",
-  noInboundAddressesFound = "noInboundAddressesFound",
-  noInboundAddressFoundForChain = "noInboundAddressFoundForChain",
-  noLastBlocksFound = "noLastBlocksFound",
-  noVersionFound = "noVersionFound",
-  noConstantsFound = "noConstantsFound",
-  noMimirsFound = "noMimirsFound",
-  noRoutesFound = "noRoutesFound",
-  quoteNotFound = "quoteNotFound",
-  ledgerSignFailed = "ledgerSignFailed",
-  ledgerWrongPayload = "ledgerWrongPayload",
-  ledgerFetchSwapFailed = "ledgerFetchSwapFailed",
-  failedToFetchTx = "failedToFetchTx",
-  failedBuildTransactionDetails = "failedBuildTransactionDetails",
-  noLegsForRoute = "noLegsForRoute",
-  noRouterAddressFound = "noRouterAddressFound",
-  noAggregatorAddressFound = "noAggregatorAddressFound",
-  noContractInstanceFound = "noContractInstanceFound",
-  noContractAddressFound = "noContractAddressFound",
-  invalidAffiliate = "invalidAffiliate",
-  thornameAffiliate = "thornameAffiliate",
-  providerNotfound = "No provider found",
-  noRecordFound = "No Record found",
-  slippageTooLow = "Slippage too low",
-  tradingHalted = "tradingHalted",
-  noWrappedGasAsset = "noWrappedGasAsset",
-  aggregatorAddressNotFound = "aggregatorAddressNotFound",
-  routerAddressNotFound = "routerAddressNotFound",
-  dummyAddressNotFound = "dummyAddressNotFound",
-  trackerError = "trackerError",
-  thorchainPoolUnavailable = "thorchainPoolUnavailable",
-  noOhlcvDataFound = "noOhlcvDataFound",
-  noTradingPairs = "noTradingPairs",
-  noLendingAvailability = "noLendingAvailability",
-  lendingRepayTooSmall = "lendingRepayTooSmall",
-  missingState = "missingState",
-  ledgerSwapNotFound = "ledgerSwapNotFound",
-  ledgerSwapNotReadyForTracking = "ledgerSwapNotReadyForTracking",
-  errorEstimatingGas = "errorEstimatingGas",
-  apiKeyInvalid = "apiKeyInvalid",
-  apiKeyFailedToUpdate = "apiKeyFailedToUpdate",
-  apiKeyExpired = "apiKeyExpired",
-  unauthorized = "unauthorized",
-  failedToCreateMemo = "failedToCreateMemo",
-  radixIncorrectInstructions = "radixIncorrectInstructions",
-  radixTxMissedParam = "radixTxMissedParam",
-  radixTxMissedAccount = "radixTxMissedAccount",
-  radixManifestParseError = "radixManifestParseError",
-  radixManifestBuildError = "radixManifestBuildError",
-  invalidAddressForChain = "invalidAddressForChain",
-  riskyAddress = "riskyAddress",
-  noRoutesToProcess = "noRoutesToProcess",
-  sellAssetAmountTooSmall = "sellAssetAmountTooSmall",
-  missingPrivateKey = "missingPrivateKey",
-  noMemoPriceProtection = "noMemoPriceProtection",
-}
-
-export enum WarningCodeEnum {
-  highSlippage = "highSlippage",
-  highPriceImpact = "highPriceImpact",
-}
-
-export enum ProviderName {
-  CAVIAR_V1 = "CAVIAR_V1",
-  CAMELOT_V3 = "CAMELOT_V3",
-  CHAINFLIP = "CHAINFLIP",
-  CHAINFLIP_STREAMING = "CHAINFLIP_STREAMING",
-  JUPITER = "JUPITER",
-  MAYACHAIN = "MAYACHAIN",
-  MAYACHAIN_STREAMING = "MAYACHAIN_STREAMING",
-  OCISWAP_V1 = "OCISWAP_V1",
-  ONEINCH = "ONEINCH",
-  OPENOCEAN_V2 = "OPENOCEAN_V2",
-  PANCAKESWAP = "PANCAKESWAP",
-  PANGOLIN_V1 = "PANGOLIN_V1",
-  SUSHISWAP_V2 = "SUSHISWAP_V2",
-  THORCHAIN = "THORCHAIN",
-  THORCHAIN_STREAMING = "THORCHAIN_STREAMING",
-  TRADERJOE_V2 = "TRADERJOE_V2",
-  UNISWAP_V2 = "UNISWAP_V2",
-  UNISWAP_V3 = "UNISWAP_V3",
-  NEAR = "NEAR",
-  GARDEN = "GARDEN",
-  OKX = "OKX",
-}
-
-export enum FeeTypeEnum {
-  LIQUIDITY = "liquidity",
-  NETWORK = "network",
-  INBOUND = "inbound",
-  OUTBOUND = "outbound",
-  AFFILIATE = "affiliate",
-  TAX = "tax",
-  PRIORITY = "priority",
-  SERVICE = "service",
-}

package/src/types/sdk.ts

@@ -1,38 +0,0 @@
-import type { AssetValue } from "../modules/assetValue";
-
-export type GenericSwapParams<T = unknown> = {
-  buyAsset?: AssetValue;
-  sellAsset?: AssetValue;
-  recipient?: string;
-  feeOptionKey?: FeeOption;
-  route: T;
-};
-
-export type SwapParams<PluginNames = string, R = unknown> = GenericSwapParams<R> & { pluginName?: PluginNames };
-
-export enum FeeOption {
-  Average = "average",
-  Fast = "fast",
-  Fastest = "fastest",
-}
-
-export enum ApproveMode {
-  Approve = "approve",
-  CheckOnly = "checkOnly",
-}
-
-export type ApproveReturnType<T extends ApproveMode> = T extends "checkOnly" ? Promise<boolean> : Promise<string>;
-
-export enum MemoType {
-  NAME_REGISTER = "~",
-  BOND = "BOND",
-  DEPOSIT = "+",
-  LEAVE = "LEAVE",
-  UNBOND = "UNBOND",
-  WITHDRAW = "-",
-  RUNEPOOL_DEPOSIT = "POOL+",
-  RUNEPOOL_WITHDRAW = "POOL-",
-  CLAIM_TCY = "tcy",
-  STAKE_TCY = "tcy+",
-  UNSTAKE_TCY = "tcy-",
-}

package/src/types/wallet.ts

@@ -1,124 +0,0 @@
-import type { Chain, getChainConfig } from "@swapkit/types";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-
-import type { AssetValue } from "../modules/assetValue";
-import type { FeeOption } from "./sdk";
-
-declare global {
-  interface WindowEventMap {
-    "eip6963:announceProvider": CustomEvent;
-  }
-}
-
-export type EthereumWindowProvider = BrowserProvider & {
-  __XDEFI?: boolean;
-  isBraveWallet?: boolean;
-  isCoinbaseWallet?: boolean;
-  isMetaMask?: boolean;
-  isOkxWallet?: boolean;
-  isKeepKeyWallet?: boolean;
-  isTrust?: boolean;
-  isTalisman?: boolean;
-  on: (event: string, callback?: () => void) => void;
-  overrideIsMetaMask?: boolean;
-  request: <T = unknown>(args: { method: string; params?: unknown[] }) => Promise<T>;
-  selectedProvider?: EthereumWindowProvider;
-};
-
-export type NetworkParams = {
-  chainId: ReturnType<typeof getChainConfig>["chainIdHex"];
-  chainName: string;
-  nativeCurrency: { name: string; symbol: string; decimals: number };
-  rpcUrls: string[];
-  blockExplorerUrls: string[];
-};
-
-export enum WalletOption {
-  BITGET = "BITGET",
-  BRAVE = "BRAVE",
-  COINBASE_MOBILE = "COINBASE_MOBILE",
-  COINBASE_WEB = "COINBASE_WEB",
-  COSMOSTATION = "COSMOSTATION",
-  CTRL = "CTRL",
-  EIP6963 = "EIP6963",
-  /**
-   * @deprecated Use PASSKEYS instead
-   */
-  EXODUS = "EXODUS",
-  KEEPKEY = "KEEPKEY",
-  KEEPKEY_BEX = "KEEPKEY_BEX",
-  KEPLR = "KEPLR",
-  KEYSTORE = "KEYSTORE",
-  LEAP = "LEAP",
-  LEDGER = "LEDGER",
-  LEDGER_LIVE = "LEDGER_LIVE",
-  METAMASK = "METAMASK",
-  OKX = "OKX",
-  OKX_MOBILE = "OKX_MOBILE",
-  ONEKEY = "ONEKEY",
-  PASSKEYS = "PASSKEYS",
-  PHANTOM = "PHANTOM",
-  POLKADOT_JS = "POLKADOT_JS",
-  RADIX_WALLET = "RADIX_WALLET",
-  TALISMAN = "TALISMAN",
-  TREZOR = "TREZOR",
-  TRONLINK = "TRONLINK",
-  TRUSTWALLET_WEB = "TRUSTWALLET_WEB",
-  VULTISIG = "VULTISIG",
-  WALLETCONNECT = "WALLETCONNECT",
-  WALLET_SELECTOR = "WALLET_SELECTOR",
-  XAMAN = "XAMAN",
-}
-
-export enum LedgerErrorCode {
-  NoError = 0x9000,
-  LockedDevice = 0x5515,
-  TC_NotFound = 65535,
-}
-
-/**
- * @deprecated CryptoChain has been deprecated - use Chain instead
- */
-export type CryptoChain = Chain;
-
-export type ChainWallet<T extends Chain> = {
-  chain: T;
-  address: string;
-  balance: AssetValue[];
-  walletType: WalletOption | string;
-  disconnect?: () => void;
-  signMessage?: (message: string) => Promise<string>;
-};
-
-export type EmptyWallet = { [key in Chain]?: unknown };
-export type BaseWallet<T extends EmptyWallet | Record<string, unknown>> = {
-  [key in Chain]: ChainWallet<key> & (T extends EmptyWallet ? T[key] : never);
-};
-
-export type EIP6963ProviderInfo = { walletId: string; uuid: string; name: string; icon: string };
-
-export type EIP6963ProviderDetail = { info: EIP6963ProviderInfo; provider: Eip1193Provider };
-
-export type EIP6963Provider = { info: EIP6963ProviderInfo; provider: Eip1193Provider };
-
-// This type represents the structure of an event dispatched by a wallet to announce its presence based on EIP-6963.
-export type EIP6963AnnounceProviderEvent = Event & { detail: EIP6963Provider };
-
-export type ChainSigner<T, S> = {
-  signTransaction: (params: T) => Promise<S> | S;
-  getAddress: () => Promise<string> | string;
-  sign?: (message: string) => Promise<string> | string;
-};
-
-export type GenericTransferParams = {
-  recipient: string;
-  assetValue: AssetValue;
-  memo?: string;
-  feeRate?: number;
-  feeOptionKey?: FeeOption;
-};
-
-export type GenericCreateTransactionParams = Omit<GenericTransferParams, "feeOptionKey" & "feeRate"> & {
-  sender: string;
-  feeRate: number;
-};

package/src/utils/__tests__/asset.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { AllChains, Chain, getChainConfig } from "@swapkit/types";
-
-import { assetFromString, fetchTokenInfo, getAssetType } from "../asset";
-
-// TODO: this should be handled via AssetValue
-const tickerMap: Record<string, string> = {
-  [Chain.Arbitrum]: "ETH",
-  [Chain.Aurora]: "ETH",
-  [Chain.Base]: "ETH",
-  [Chain.BinanceSmartChain]: "BNB",
-  [Chain.Monad]: "MON",
-  [Chain.Cosmos]: "ATOM",
-  [Chain.Maya]: "CACAO",
-  [Chain.Optimism]: "ETH",
-  [Chain.THORChain]: "RUNE",
-  [Chain.Tron]: "TRX",
-  [Chain.XLayer]: "OKB",
-};
-
-describe("getAssetType", () => {
-  describe("when isSynth is true", () => {
-    test('should return "Synth"', () => {
-      const result = getAssetType({ chain: Chain.Bitcoin, symbol: "BTC/BTC" });
-      expect(result).toBe("Synth");
-    });
-  });
-
-  describe("when isSynth is false", () => {
-    describe("for gas assets on given chain", () => {
-      for (const chain of AllChains) {
-        test(`should return "Native" for chain ${chain} asset`, () => {
-          const ticker = tickerMap[chain] || chain;
-          const result = getAssetType({ chain: chain as Chain, symbol: ticker });
-
-          expect(result).toBe("Native");
-        });
-      }
-    });
-
-    describe("for non-gas assets on given chain", () => {
-      for (const chain of AllChains) {
-        test(`should return ${chain} for chain ${chain} asset`, () => {
-          const result = getAssetType({ chain: chain as Chain, symbol: "USDT" });
-
-          expect(result).toBe(chain);
-        });
-      }
-    });
-  });
-});
-
-describe("fetchTokenInfo", () => {
-  /**
-   * Test out native
-   */
-  const filteredChains = AllChains.filter((c) => ![Chain.Ethereum, Chain.Avalanche].includes(c));
-
-  for (const chain of filteredChains) {
-    describe(chain, () => {
-      test(`returns proper decimal for native ${chain} asset`, async () => {
-        const { decimals } = await fetchTokenInfo({ address: "", chain });
-        const { baseDecimal } = getChainConfig(chain);
-        expect(decimals).toBe(baseDecimal);
-      });
-    });
-  }
-
-  describe("ETH", () => {
-    // TODO: if too many requests, this will fail due to timeout
-    test.todo("returns proper decimal for eth and it's assets", async () => {
-      const { decimals: ethDecimal } = await fetchTokenInfo({ address: "", chain: Chain.Ethereum });
-      expect(ethDecimal).toBe(getChainConfig(Chain.Ethereum).baseDecimal);
-      await Bun.sleep(500);
-
-      const { decimals: usdcDecimal } = await fetchTokenInfo({
-        address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-        chain: Chain.Ethereum,
-      });
-      expect(usdcDecimal).toBe(6);
-      await Bun.sleep(500);
-
-      const { decimals: wbtcDecimal } = await fetchTokenInfo({
-        address: "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
-        chain: Chain.Ethereum,
-      });
-      expect(wbtcDecimal).toBe(8);
-      await Bun.sleep(500);
-
-      const { decimals: kindDecimal } = await fetchTokenInfo({
-        address: "0x4618519de4c304f3444ffa7f812dddc2971cc688",
-        chain: Chain.Ethereum,
-      });
-      expect(kindDecimal).toBe(8);
-      await Bun.sleep(500);
-
-      const { decimals: shitcoinDecimal } = await fetchTokenInfo({
-        address: "0xCa208BfD69ae6D2667f1FCbE681BAe12767c0078",
-        chain: Chain.Ethereum,
-      });
-      expect(shitcoinDecimal).toBe(0);
-      await Bun.sleep(500);
-    });
-  });
-
-  describe("AVAX", () => {
-    // TODO: if too many requests, this will fail due to timeout
-    test.todo("returns proper decimal for avax and it's assets", async () => {
-      const { decimals: avaxDecimal } = await fetchTokenInfo({ address: "", chain: Chain.Avalanche });
-      expect(avaxDecimal).toBe(getChainConfig(Chain.Avalanche).baseDecimal);
-
-      const { decimals: wbtceDecimal } = await fetchTokenInfo({
-        address: "0x50b7545627a5162f82a992c33b87adc75187b218",
-        chain: Chain.Avalanche,
-      });
-      expect(wbtceDecimal).toBe(8);
-
-      const { decimals: btcbDecimal } = await fetchTokenInfo({
-        address: "0x152b9d0FdC40C096757F570A51E494bd4b943E50",
-        chain: Chain.Avalanche,
-      });
-      expect(btcbDecimal).toBe(8);
-
-      const { decimals: timeDecimal } = await fetchTokenInfo({
-        address: "0xb54f16fB19478766A268F172C9480f8da1a7c9C3",
-        chain: Chain.Avalanche,
-      });
-      expect(timeDecimal).toBe(9);
-
-      const { decimals: usdtDecimal } = await fetchTokenInfo({
-        address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
-        chain: Chain.Avalanche,
-      });
-      expect(usdtDecimal).toBe(6);
-
-      const { decimals: usdcDecimal } = await fetchTokenInfo({
-        address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-        chain: Chain.Avalanche,
-      });
-      expect(usdcDecimal).toBe(6);
-    });
-  });
-
-  describe("Radix", () => {
-    test.todo("returns proper decimal for radix and it's assets", async () => {
-      const { decimals: radixDecimal } = await fetchTokenInfo({ address: "", chain: Chain.Radix });
-      expect(radixDecimal).toBe(getChainConfig(Chain.Radix).baseDecimal);
-      await Bun.sleep(500);
-
-      const { decimals: xwBTCDecimal } = await fetchTokenInfo({
-        address: "xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
-        chain: Chain.Radix,
-      });
-      expect(xwBTCDecimal).toBe(8);
-      await Bun.sleep(500);
-    });
-  });
-});
-
-describe("assetFromString", () => {
-  test("should return the correct object", () => {
-    const assetString = "THOR.RUNE";
-    const result = assetFromString(assetString);
-
-    expect(result).toEqual({ chain: Chain.THORChain, symbol: "RUNE", synth: false, ticker: "RUNE" });
-  });
-
-  test("should return the correct object for multiple dashes", () => {
-    const assetString = "ETH.PENDLE-LPT-0x1234";
-    const result = assetFromString(assetString);
-
-    expect(result).toEqual({ chain: Chain.Ethereum, symbol: "PENDLE-LPT-0x1234", synth: false, ticker: "PENDLE-LPT" });
-  });
-
-  test.todo("should return the correct object for Radix resource", () => {
-    const assetString = "XRD.xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75";
-    const result = assetFromString(assetString);
-
-    expect(result).toEqual({
-      chain: Chain.Radix,
-      symbol: "xwBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
-      synth: false,
-      ticker: "xwBTC",
-    });
-  });
-});

package/src/utils/__tests__/derivationPath.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Chain } from "@swapkit/types";
-
-import type { DerivationPathArray } from "../../types";
-import {
-  DerivationPath,
-  derivationPathToString,
-  getDerivationPathFor,
-  getWalletFormatFor,
-  updateDerivationPath,
-} from "../derivationPath";
-
-describe("derivationPathToString", () => {
-  test("full 5-element path", () => {
-    expect(derivationPathToString([44, 60, 0, 0, 0] as DerivationPathArray)).toBe("m/44'/60'/0'/0/0");
-    expect(derivationPathToString([84, 0, 0, 0, 5] as DerivationPathArray)).toBe("m/84'/0'/0'/0/5");
-  });
-
-  test("4-element path without index", () => {
-    expect(derivationPathToString([44, 60, 0, 0] as DerivationPathArray)).toBe("m/44'/60'/0'/0");
-    expect(derivationPathToString([49, 2, 0, 1] as DerivationPathArray)).toBe("m/49'/2'/0'/1");
-  });
-
-  test("3-element account path", () => {
-    expect(derivationPathToString([44, 60, 0] as unknown as DerivationPathArray)).toBe("m/44'/60'/0'");
-    expect(derivationPathToString([44, 501, 5] as unknown as DerivationPathArray)).toBe("m/44'/501'/5'");
-  });
-});
-
-describe("updateDerivationPath", () => {
-  const basePath: DerivationPathArray = [44, 60, 0, 0, 0];
-
-  test("updates index (last element)", () => {
-    expect(updateDerivationPath(basePath, { index: 5 })).toEqual([44, 60, 0, 0, 5]);
-    expect(updateDerivationPath(basePath, { index: 100 })).toEqual([44, 60, 0, 0, 100]);
-  });
-
-  test("updates change (4th element)", () => {
-    expect(updateDerivationPath(basePath, { change: 1 })).toEqual([44, 60, 0, 1, 0]);
-    expect(updateDerivationPath([84, 0, 2, 0, 3], { change: 1 })).toEqual([84, 0, 2, 1, 3]);
-  });
-
-  test("updates account (3rd element)", () => {
-    expect(updateDerivationPath(basePath, { account: 5 })).toEqual([44, 60, 5, 0, 0]);
-    expect(updateDerivationPath([84, 0, 0, 1, 10], { account: 3 })).toEqual([84, 0, 3, 1, 10]);
-  });
-
-  test("returns unchanged path for empty params", () => {
-    expect(updateDerivationPath(basePath, {} as any)).toEqual(basePath);
-  });
-});
-
-describe("getDerivationPathFor", () => {
-  describe("EVM chains", () => {
-    test("Ethereum default path", () => {
-      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 0 })).toEqual([44, 60, 0, 0, 0]);
-      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 5 })).toEqual([44, 60, 0, 0, 5]);
-    });
-
-    test("Ethereum legacy type", () => {
-      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 3, type: "legacy" })).toEqual([44, 60, 0, 3]);
-    });
-
-    test("Ethereum account type", () => {
-      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 2, type: "account" })).toEqual([44, 60, 0, 2]);
-    });
-
-    test("Ethereum ledgerLive type", () => {
-      expect(getDerivationPathFor({ chain: Chain.Ethereum, index: 0, type: "ledgerLive" })).toEqual([44, 60, 0, 0, 0]);
-      expect(getDerivationPathFor({ addressIndex: 1, chain: Chain.Ethereum, index: 2, type: "ledgerLive" })).toEqual([
-        44, 60, 2, 0, 1,
-      ]);
-    });
-
-    test("other EVM chains use same derivation", () => {
-      expect(getDerivationPathFor({ chain: Chain.BinanceSmartChain, index: 0 })).toEqual([44, 60, 0, 0, 0]);
-      expect(getDerivationPathFor({ chain: Chain.Avalanche, index: 0 })).toEqual([44, 60, 0, 0, 0]);
-      expect(getDerivationPathFor({ chain: Chain.Arbitrum, index: 0 })).toEqual([44, 60, 0, 0, 0]);
-    });
-  });
-
-  describe("Solana", () => {
-    test("default path", () => {
-      const result = getDerivationPathFor({ chain: Chain.Solana, index: 0 });
-      expect(result[1]).toBe(501);
-    });
-
-    test("account type", () => {
-      expect(getDerivationPathFor({ chain: Chain.Solana, index: 3, type: "account" })).toEqual([44, 501, 0, 3]);
-    });
-  });
-
-  describe("UTXO chains", () => {
-    test("Bitcoin nativeSegwitMiddleAccount", () => {
-      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 0, type: "nativeSegwitMiddleAccount" })).toEqual([
-        84, 0, 0, 0, 0,
-      ]);
-      expect(
-        getDerivationPathFor({ addressIndex: 5, chain: Chain.Bitcoin, index: 2, type: "nativeSegwitMiddleAccount" }),
-      ).toEqual([84, 0, 2, 0, 5]);
-    });
-
-    test("Bitcoin segwit", () => {
-      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 3, type: "segwit" })).toEqual([49, 0, 0, 0, 3]);
-    });
-
-    test("Bitcoin legacy", () => {
-      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 0, type: "legacy" })).toEqual([44, 0, 0, 0, 0]);
-      expect(getDerivationPathFor({ chain: Chain.Bitcoin, index: 5, type: "legacy" })).toEqual([44, 0, 0, 0, 5]);
-    });
-
-    test("Litecoin uses chainId 2", () => {
-      expect(getDerivationPathFor({ chain: Chain.Litecoin, index: 0, type: "legacy" })).toEqual([44, 2, 0, 0, 0]);
-      expect(getDerivationPathFor({ chain: Chain.Litecoin, index: 0, type: "segwit" })).toEqual([49, 2, 0, 0, 0]);
-    });
-  });
-});
-
-describe("getWalletFormatFor", () => {
-  test("returns legacy for purpose 44", () => {
-    expect(getWalletFormatFor("m/44'/0'/0'/0/0")).toBe("legacy");
-    expect(getWalletFormatFor("m/44'/60'/0'/0/0")).toBe("legacy");
-  });
-
-  test("returns p2sh for purpose 49", () => {
-    expect(getWalletFormatFor("m/49'/0'/0'/0/0")).toBe("p2sh");
-    expect(getWalletFormatFor("m/49'/2'/0'/0/0")).toBe("p2sh");
-  });
-
-  test("returns bech32 for purpose 84 and others", () => {
-    expect(getWalletFormatFor("m/84'/0'/0'/0/0")).toBe("bech32");
-    expect(getWalletFormatFor("m/86'/0'/0'/0/0")).toBe("bech32");
-  });
-});
-
-describe("DerivationPath export", () => {
-  test("exports string paths for common chains", () => {
-    expect(typeof DerivationPath[Chain.Ethereum]).toBe("string");
-    expect(typeof DerivationPath[Chain.Bitcoin]).toBe("string");
-    expect(DerivationPath[Chain.Ethereum]).toMatch(/^m\/\d+'\/\d+'\/\d+'/);
-  });
-});