@tcswap/helpers 4.5.15

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from "./commonTypes";
+export * from "./derivationPath";
+export * from "./quotes";
+export * from "./sdk";
+export * from "./wallet";

package/src/types/quotes.ts

@@ -0,0 +1,182 @@
+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",
+  rateExpired = "rateExpired",
+  amountTooSmall = "amountTooSmall",
+  amountTooBig = "amountTooBig",
+  amountOutOfRange = "amountOutOfRange",
+  requestTimeOut = "requestTimeOut",
+  networkError = "networkError",
+  unknownApiError = "unknownApiError",
+  invalidResponseFormat = "invalidResponseFormat",
+}
+
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,124 @@
+import type { Chain, getChainConfig } from "@tcswap/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

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "bun:test";
+import { AllChains, Chain, getChainConfig } from "@tcswap/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

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "bun:test";
+import { Chain } from "@tcswap/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+'/);
+  });
+});