@uswap/toolboxes 4.3.6

package/src/evm/toolbox/evm.ts

@@ -0,0 +1,67 @@
+import { Chain, type EVMChain, FeeOption, getRPCUrl } from "@uswap/helpers";
+import { match, P } from "ts-pattern";
+
+import { getEvmApi } from "../api";
+import { multicallAbi } from "../contracts/eth/multicall";
+import { getIsEIP1559Compatible, getNetworkParams, getProvider } from "../helpers";
+import type { EVMToolboxParams } from "../types";
+import { BaseEVMToolbox } from "./baseEVMToolbox";
+
+export async function ETHToolbox({ provider, ...signer }: EVMToolboxParams) {
+  const evmToolbox = await createEvmToolbox(Chain.Ethereum)({ provider, ...signer });
+  async function multicall(
+    callTuples: { address: string; data: string }[],
+    multicallAddress = "0x5ba1e12693dc8f9c48aad8770482f4739beed696",
+    funcName = "aggregate",
+    feeOptionKey: FeeOption = FeeOption.Fast,
+  ) {
+    const txObject = await evmToolbox.createContractTxObject({
+      abi: multicallAbi,
+      contractAddress: multicallAddress,
+      funcName,
+      funcParams: [callTuples],
+    });
+
+    return evmToolbox.sendTransaction({ ...txObject, feeOptionKey });
+  }
+
+  return { ...evmToolbox, multicall };
+}
+
+export const ARBToolbox = createEvmToolbox(Chain.Arbitrum);
+export const AURORAToolbox = createEvmToolbox(Chain.Aurora);
+export const AVAXToolbox = createEvmToolbox(Chain.Avalanche);
+export const BASEToolbox = createEvmToolbox(Chain.Base);
+export const BERAToolbox = createEvmToolbox(Chain.Berachain);
+export const BSCToolbox = createEvmToolbox(Chain.BinanceSmartChain);
+export const BotanixToolbox = createEvmToolbox(Chain.Botanix);
+export const COREToolbox = createEvmToolbox(Chain.Core);
+export const CORNToolbox = createEvmToolbox(Chain.Corn);
+export const CROToolbox = createEvmToolbox(Chain.Cronos);
+export const GNOToolbox = createEvmToolbox(Chain.Gnosis);
+export const HYPEREVMToolbox = createEvmToolbox(Chain.Hyperevm);
+export const MATICToolbox = createEvmToolbox(Chain.Polygon);
+export const SONICToolbox = createEvmToolbox(Chain.Sonic);
+export const UNIToolbox = createEvmToolbox(Chain.Unichain);
+export const XLayerToolbox = createEvmToolbox(Chain.XLayer);
+export const MONADToolbox = createEvmToolbox(Chain.Monad);
+export const MEGAETHToolbox = createEvmToolbox(Chain.MegaETH as EVMChain);
+
+function createEvmToolbox<C extends EVMChain>(chain: C) {
+  return async function createEvmToolbox({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) {
+    const { HDNodeWallet } = await import("ethers");
+    const rpcUrl = await getRPCUrl(chain);
+
+    const provider = providerParam || (await getProvider(chain, rpcUrl));
+
+    const isEIP1559Compatible = getIsEIP1559Compatible(chain);
+    const signer = match(toolboxSignerParams)
+      .with({ phrase: P.string }, ({ phrase }) => HDNodeWallet.fromPhrase(phrase).connect(provider))
+      .with({ signer: P.any }, ({ signer }) => signer)
+      .otherwise(() => undefined);
+
+    const evmToolbox = BaseEVMToolbox({ chain, isEIP1559Compatible, provider, signer });
+
+    return { ...evmToolbox, getBalance: getEvmApi(chain).getBalance, getNetworkParams: getNetworkParams(chain) };
+  };
+}

package/src/evm/toolbox/index.ts

@@ -0,0 +1,44 @@
+import { Chain, type EVMChain } from "@uswap/helpers";
+import { match } from "ts-pattern";
+
+import { getProvider } from "../helpers";
+import type { EVMToolboxes, EVMToolboxParams } from "../types";
+import * as evmToolboxes from "./evm";
+import { OPToolbox } from "./op";
+
+export async function getEvmToolbox<T extends EVMChain>(chain: T, params?: EVMToolboxParams) {
+  const toolboxParams = { ...params, provider: params?.provider || (await getProvider(chain)) };
+
+  type Toolbox = Promise<EVMToolboxes[T]>;
+
+  return (
+    match(chain as EVMChain)
+      .returnType<Toolbox>()
+      .with(Chain.Arbitrum, () => evmToolboxes.ARBToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Aurora, () => evmToolboxes.AURORAToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Avalanche, () => evmToolboxes.AVAXToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Base, () => evmToolboxes.BASEToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Berachain, () => evmToolboxes.BERAToolbox(toolboxParams) as Toolbox)
+      .with(Chain.BinanceSmartChain, () => evmToolboxes.BSCToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Botanix, () => evmToolboxes.SONICToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Core, () => evmToolboxes.COREToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Corn, () => evmToolboxes.CORNToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Cronos, () => evmToolboxes.CROToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Ethereum, () => evmToolboxes.ETHToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Gnosis, () => evmToolboxes.GNOToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Hyperevm, () => evmToolboxes.HYPEREVMToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Optimism, () => OPToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Polygon, () => evmToolboxes.MATICToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Sonic, () => evmToolboxes.SONICToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Unichain, () => evmToolboxes.UNIToolbox(toolboxParams) as Toolbox)
+      .with(Chain.XLayer, () => evmToolboxes.XLayerToolbox(toolboxParams) as Toolbox)
+      .with(Chain.Monad, () => evmToolboxes.MONADToolbox(toolboxParams) as Toolbox)
+      // @ts-expect-error TODO: Remove once live
+      .with(Chain.MegaETH, () => evmToolboxes.MEGAETHToolbox(toolboxParams) as Toolbox)
+      .exhaustive()
+  );
+}
+
+export * from "./baseEVMToolbox";
+export * from "./evm";
+export * from "./op";

package/src/evm/toolbox/op.ts

@@ -0,0 +1,156 @@
+import { applyFeeMultiplierToBigInt, Chain, FeeOption, getChainConfig, getRPCUrl, SwapKitError } from "@uswap/helpers";
+import type { Authorization, BrowserProvider, JsonRpcProvider, Provider, TransactionRequest } from "ethers";
+import { Contract, HDNodeWallet } from "ethers";
+import { match, P } from "ts-pattern";
+import { getEvmApi } from "../api";
+import { gasOracleAbi } from "../contracts/op/gasOracle";
+import { getProvider } from "../helpers";
+import type { EVMToolboxParams } from "../types";
+import { BaseEVMToolbox } from "./baseEVMToolbox";
+
+const GAS_PRICE_ORACLE_ADDRESS = "0x420000000000000000000000000000000000000f";
+
+function connectGasPriceOracle<P extends Provider>(provider: P) {
+  return new Contract(GAS_PRICE_ORACLE_ADDRESS, gasOracleAbi, provider);
+}
+
+function getL1GasPriceFetcher<P extends Provider>(provider: P) {
+  return async function getL1GasPrice() {
+    const gasPriceOracle = connectGasPriceOracle(provider);
+
+    if (gasPriceOracle && "l1BaseFee" in gasPriceOracle) {
+      return (await gasPriceOracle?.l1BaseFee()) as unknown as bigint;
+    }
+
+    return undefined;
+  };
+}
+
+function serializeTx<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function serializeTx({ from, to, nonce, ...tx }: TransactionRequest) {
+    const { Transaction } = await import("ethers");
+
+    if (!to) throw new SwapKitError("toolbox_evm_invalid_transaction", { error: "Missing to address" });
+
+    return Transaction.from({
+      ...tx,
+      authorizationList: tx.authorizationList as Authorization[],
+      nonce: nonce ? nonce : from ? await provider.getTransactionCount(from) : 0,
+      to: to as string,
+    }).serialized;
+  };
+}
+
+function estimateL1GasCost<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateL1GasCost(tx: TransactionRequest) {
+    const gasPriceOracle = connectGasPriceOracle(provider);
+    const serializedTx = await serializeTx(provider)(tx);
+
+    if (gasPriceOracle && "getL1Fee" in gasPriceOracle) {
+      return gasPriceOracle.getL1Fee(serializedTx);
+    }
+  };
+}
+
+function estimateL2GasCost<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateL2GasCost(tx: TransactionRequest) {
+    const l2GasPrice = await provider.send("eth_gasPrice", []);
+    const l2GasCost = await provider.estimateGas(tx);
+    return l2GasPrice.mul(l2GasCost);
+  };
+}
+
+function estimateTotalGasCost<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateTotalGasCost(tx: TransactionRequest) {
+    const l1GasCost = await estimateL1GasCost(provider)(tx);
+    const l2GasCost = await estimateL2GasCost(provider)(tx);
+    return l1GasCost.add(l2GasCost);
+  };
+}
+
+function estimateL1Gas<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
+  return async function estimateL1Gas(tx: TransactionRequest) {
+    const gasPriceOracle = connectGasPriceOracle(provider);
+    const serializedTx = await serializeTx(provider)(tx);
+
+    if (gasPriceOracle && "getL1GasUsed" in gasPriceOracle) {
+      return gasPriceOracle.getL1GasUsed(serializedTx);
+    }
+  };
+}
+
+function getNetworkParams() {
+  const { baseDecimal, chainId, explorerUrl, name, rpcUrls } = getChainConfig(Chain.Optimism);
+
+  return {
+    blockExplorerUrls: [explorerUrl],
+    chainId,
+    chainName: name,
+    nativeCurrency: { decimals: baseDecimal, name: "Ethereum", symbol: Chain.Ethereum },
+    rpcUrls,
+  };
+}
+
+async function estimateGasPrices(provider: Provider) {
+  try {
+    const { maxFeePerGas, maxPriorityFeePerGas, gasPrice } = await provider.getFeeData();
+    const l1GasPrice = await getL1GasPriceFetcher(provider)();
+    const price = gasPrice as bigint;
+
+    if (!(maxFeePerGas && maxPriorityFeePerGas)) {
+      throw new SwapKitError("toolbox_evm_no_fee_data");
+    }
+
+    return {
+      [FeeOption.Average]: { gasPrice: price, l1GasPrice, maxFeePerGas, maxPriorityFeePerGas },
+      [FeeOption.Fast]: {
+        gasPrice: applyFeeMultiplierToBigInt(price, FeeOption.Fast),
+        l1GasPrice: applyFeeMultiplierToBigInt(l1GasPrice || 0n, FeeOption.Fast),
+        maxFeePerGas,
+        maxPriorityFeePerGas: applyFeeMultiplierToBigInt(maxPriorityFeePerGas, FeeOption.Fast),
+      },
+      [FeeOption.Fastest]: {
+        gasPrice: applyFeeMultiplierToBigInt(price, FeeOption.Fastest),
+        l1GasPrice: applyFeeMultiplierToBigInt(l1GasPrice || 0n, FeeOption.Fastest),
+        maxFeePerGas,
+        maxPriorityFeePerGas: applyFeeMultiplierToBigInt(maxPriorityFeePerGas, FeeOption.Fastest),
+      },
+    } as {
+      [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+      };
+    };
+  } catch (error) {
+    throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+      error: (error as any).msg ?? (error as any).toString(),
+    });
+  }
+}
+
+export async function OPToolbox({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) {
+  const chain = Chain.Optimism;
+  const rpcUrl = await getRPCUrl(chain);
+  const provider = providerParam || (await getProvider(chain, rpcUrl));
+  const signer = match(toolboxSignerParams)
+    .with({ phrase: P.string }, ({ phrase }) => HDNodeWallet.fromPhrase(phrase).connect(provider))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  const evmToolbox = BaseEVMToolbox({ provider, signer });
+  const getL1GasPrice = getL1GasPriceFetcher(provider);
+
+  return {
+    ...evmToolbox,
+    estimateGasPrices: estimateGasPrices(provider),
+    estimateL1Gas: estimateL1Gas(provider),
+    estimateL1GasCost: estimateL1GasCost(provider),
+    estimateL2GasCost: estimateL2GasCost(provider),
+    estimateTotalGasCost: estimateTotalGasCost(provider),
+    getBalance: getEvmApi(Chain.Optimism).getBalance,
+    getL1GasPrice,
+    getNetworkParams,
+  };
+}

package/src/evm/types.ts

@@ -0,0 +1,146 @@
+import type {
+  AssetValue,
+  ChainSigner,
+  DerivationPathArray,
+  FeeOption,
+  GenericCreateTransactionParams,
+  GenericTransferParams,
+} from "@uswap/helpers";
+import { Chain } from "@uswap/helpers";
+import type {
+  BigNumberish,
+  BrowserProvider,
+  JsonFragment,
+  JsonRpcProvider,
+  JsonRpcSigner,
+  Signer,
+  Transaction,
+} from "ethers";
+import type { getProvider } from "./index";
+import type {
+  ARBToolbox,
+  AURORAToolbox,
+  AVAXToolbox,
+  BASEToolbox,
+  BERAToolbox,
+  BSCToolbox,
+  COREToolbox,
+  CORNToolbox,
+  CROToolbox,
+  ETHToolbox,
+  GNOToolbox,
+  HYPEREVMToolbox,
+  MATICToolbox,
+  MEGAETHToolbox,
+  MONADToolbox,
+  OPToolbox,
+  SONICToolbox,
+  UNIToolbox,
+  XLayerToolbox,
+} from "./toolbox";
+
+export enum EthNetwork {
+  Test = "goerli",
+  Main = "homestead",
+}
+
+export type ApproveParams = {
+  assetAddress: string;
+  spenderAddress: string;
+  feeOptionKey?: FeeOption;
+  amount?: BigNumberish;
+  from?: string;
+  // Optional fallback in case estimation for gas limit fails
+  gasLimitFallback?: BigNumberish;
+  nonce?: number;
+};
+
+export type ApprovedParams = { assetAddress: string; spenderAddress: string; from: string };
+
+export type IsApprovedParams = ApprovedParams & { amount?: BigNumberish };
+
+export type CallParams = {
+  callProvider?: Awaited<ReturnType<typeof getProvider>>;
+  contractAddress: string;
+  abi: readonly JsonFragment[];
+  funcName: string;
+  funcParams?: unknown[];
+  txOverrides?: Partial<Transaction>;
+  feeOption?: FeeOption;
+};
+
+export type EstimateCallParams = Pick<
+  CallParams,
+  "contractAddress" | "abi" | "funcName" | "funcParams" | "txOverrides"
+>;
+
+export type EVMTransferParams = GenericTransferParams & { sender?: string };
+
+export type EVMCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & {
+  gasLimit?: bigint;
+  gasPrice?: bigint;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  data?: string;
+  nonce?: number;
+};
+
+export type EVMMaxSendableAmountsParams = {
+  from: string;
+  assetValue: AssetValue;
+  feeOptionKey?: FeeOption;
+  memo?: string;
+  abi?: readonly JsonFragment[];
+  funcName?: string;
+  contractAddress?: string;
+  funcParams?: unknown[];
+  txOverrides?: Partial<Transaction>;
+};
+
+export type EVMTxBaseParams<T = bigint> = {
+  to?: string;
+  from?: string;
+  nonce?: number;
+  gasLimit?: T;
+  data?: string;
+  value?: T;
+  chainId?: T;
+};
+
+export type EIP1559TxParams<T = bigint> = EVMTxBaseParams<T> & {
+  type?: number;
+  maxFeePerGas?: T;
+  maxPriorityFeePerGas?: T;
+};
+
+export type LegacyEVMTxParams<T = bigint> = EVMTxBaseParams<T> & { gasPrice?: T };
+
+export type EVMTxParams = EIP1559TxParams | LegacyEVMTxParams;
+
+export type EVMToolboxParams = { provider?: BrowserProvider | JsonRpcProvider } & (
+  | { signer?: (ChainSigner<EVMTransferParams, string> & Signer) | JsonRpcSigner }
+  | { phrase?: string; derivationPath?: DerivationPathArray; index?: number }
+);
+
+export type EVMToolboxes = {
+  [Chain.Arbitrum]: Awaited<ReturnType<typeof ARBToolbox>>;
+  [Chain.Aurora]: Awaited<ReturnType<typeof AURORAToolbox>>;
+  [Chain.Avalanche]: Awaited<ReturnType<typeof AVAXToolbox>>;
+  [Chain.Base]: Awaited<ReturnType<typeof BASEToolbox>>;
+  [Chain.Berachain]: Awaited<ReturnType<typeof BERAToolbox>>;
+  [Chain.BinanceSmartChain]: Awaited<ReturnType<typeof BSCToolbox>>;
+  [Chain.Botanix]: Awaited<ReturnType<typeof SONICToolbox>>;
+  [Chain.Core]: Awaited<ReturnType<typeof COREToolbox>>;
+  [Chain.Corn]: Awaited<ReturnType<typeof CORNToolbox>>;
+  [Chain.Cronos]: Awaited<ReturnType<typeof CROToolbox>>;
+  [Chain.Ethereum]: Awaited<ReturnType<typeof ETHToolbox>>;
+  [Chain.Gnosis]: Awaited<ReturnType<typeof GNOToolbox>>;
+  [Chain.Hyperevm]: Awaited<ReturnType<typeof HYPEREVMToolbox>>;
+  [Chain.MegaETH]: Awaited<ReturnType<typeof MEGAETHToolbox>>;
+  [Chain.Monad]: Awaited<ReturnType<typeof MONADToolbox>>;
+  [Chain.Optimism]: Awaited<ReturnType<typeof OPToolbox>>;
+  [Chain.Polygon]: Awaited<ReturnType<typeof MATICToolbox>>;
+  [Chain.Sonic]: Awaited<ReturnType<typeof SONICToolbox>>;
+  [Chain.Unichain]: Awaited<ReturnType<typeof UNIToolbox>>;
+  [Chain.XLayer]: Awaited<ReturnType<typeof XLayerToolbox>>;
+};

package/src/index.ts

@@ -0,0 +1,260 @@
+import {
+  AssetValue,
+  Chain,
+  type CosmosChain,
+  CosmosChains,
+  type EVMChain,
+  EVMChains,
+  FeeOption,
+  type GenericCreateTransactionParams,
+  type SubstrateChain,
+  SubstrateChains,
+  SwapKitError,
+  type UTXOChain,
+  UTXOChains,
+} from "@uswap/helpers";
+import type { getCardanoToolbox } from "./cardano";
+import type { getCosmosToolbox } from "./cosmos";
+import type { ETHToolbox, EVMCreateTransactionParams, getEvmToolbox } from "./evm";
+import type { getNearToolbox } from "./near";
+import type { RadixToolbox } from "./radix";
+import type { getRippleToolbox } from "./ripple";
+import type { getSolanaToolbox, SolanaCreateTransactionParams } from "./solana";
+import type { getSubstrateToolbox } from "./substrate";
+import type { getSuiToolbox, SuiCreateTransactionParams } from "./sui";
+import type { getTONToolbox } from "./ton";
+import type { createTronToolbox } from "./tron";
+import type { getUtxoToolbox } from "./utxo";
+
+export * from "./types";
+
+export async function getAddressValidator() {
+  const { match } = await import("ts-pattern");
+  const { evmValidateAddress } = await import("./evm");
+  const { getCardanoAddressValidator } = await import("./cardano");
+  const { getCosmosValidateAddress } = await import("./cosmos");
+  const { getSolanaAddressValidator } = await import("./solana");
+  const { getSuiAddressValidator } = await import("./sui");
+  const { getTONAddressValidator } = await import("./ton");
+  const { getTronAddressValidator } = await import("./tron");
+  const { getUTXOAddressValidator } = await import("./utxo");
+  const { getValidateNearAddress } = await import("./near");
+  const { radixValidateAddress } = await import("./radix");
+  const { rippleValidateAddress } = await import("./ripple");
+  const { substrateValidateAddress } = await import("./substrate");
+
+  const cardanoValidateAddress = await getCardanoAddressValidator();
+  const nearValidateAddress = await getValidateNearAddress();
+  const solanaValidateAddress = await getSolanaAddressValidator();
+  const suiValidateAddress = await getSuiAddressValidator();
+  const tonValidateAddress = await getTONAddressValidator();
+  const tronValidateAddress = await getTronAddressValidator();
+  const utxoValidateAddress = await getUTXOAddressValidator();
+
+  return function validateAddress({ address, chain }: { address: string; chain: Chain }) {
+    const isValid = match(chain)
+      .with(...EVMChains, () => evmValidateAddress({ address }))
+      .with(...UTXOChains, () => utxoValidateAddress({ address, chain: chain as UTXOChain }))
+      .with(Chain.Cosmos, Chain.Kujira, Chain.Noble, Chain.Maya, Chain.THORChain, (chain) => {
+        const cosmosValidateAddress = getCosmosValidateAddress(chain);
+        return cosmosValidateAddress(address);
+      })
+      .with(Chain.Chainflip, Chain.Polkadot, () =>
+        substrateValidateAddress({ address, chain: chain as SubstrateChain }),
+      )
+      .with(Chain.Radix, () => radixValidateAddress(address))
+      .with(Chain.Near, () => nearValidateAddress(address))
+      .with(Chain.Ripple, () => rippleValidateAddress(address))
+      .with(Chain.Solana, () => solanaValidateAddress(address))
+      .with(Chain.Sui, () => suiValidateAddress(address))
+      .with(Chain.Ton, () => tonValidateAddress(address))
+      .with(Chain.Tron, () => tronValidateAddress(address))
+      .with(Chain.Cardano, () => cardanoValidateAddress(address))
+      .otherwise(() => false);
+
+    return isValid;
+  };
+}
+
+export function getFeeEstimator<T extends keyof CreateTransactionParams>(chain: T) {
+  return async function estimateFee(params: CreateTransactionParams[T]) {
+    const { match } = await import("ts-pattern");
+
+    return match(chain as Chain)
+      .returnType<Promise<AssetValue>>()
+      .with(...EVMChains, async (chain) => {
+        const toolbox = await getToolbox(chain);
+        const txObject = await toolbox.createTransaction(params);
+
+        return (toolbox as Awaited<ReturnType<typeof ETHToolbox>>).estimateTransactionFee({
+          ...txObject,
+          chain,
+          feeOption: params.feeOptionKey || FeeOption.Fast,
+        });
+      })
+      .with(
+        Chain.Bitcoin,
+        Chain.BitcoinCash,
+        Chain.Dogecoin,
+        Chain.Dash,
+        Chain.Litecoin,
+        Chain.Polkadot,
+        Chain.Solana,
+        Chain.Ripple,
+        Chain.Tron,
+        Chain.Near,
+        Chain.Cardano,
+        async (chain) => {
+          const toolbox = await getToolbox(chain);
+          return toolbox.estimateTransactionFee(params) as Promise<AssetValue>;
+        },
+      )
+      .with(Chain.Sui, async () => {
+        const { getSuiToolbox } = await import("./sui");
+        const suiToolbox = await getSuiToolbox();
+        return suiToolbox.estimateTransactionFee(params as SuiCreateTransactionParams);
+      })
+      .with(Chain.Ton, async () => {
+        const { getTONToolbox } = await import("./ton");
+        const tonToolbox = await getTONToolbox();
+        return tonToolbox.estimateTransactionFee();
+      })
+      .with(...CosmosChains, async () => {
+        const { estimateTransactionFee } = await import("./cosmos");
+        return estimateTransactionFee(params);
+      })
+      .otherwise(async () => AssetValue.from({ chain }));
+  };
+}
+
+type Toolboxes = {
+  [key in EVMChain]: Awaited<ReturnType<typeof getEvmToolbox>>;
+} & {
+  [key in UTXOChain]: Awaited<ReturnType<typeof getUtxoToolbox>>;
+} & {
+  [key in CosmosChain]: Awaited<ReturnType<typeof getCosmosToolbox>>;
+} & {
+  [key in SubstrateChain]: Awaited<ReturnType<typeof getSubstrateToolbox>>;
+} & {
+  [Chain.Radix]: Awaited<ReturnType<typeof RadixToolbox>>;
+  [Chain.Near]: Awaited<ReturnType<typeof getNearToolbox>>;
+  [Chain.Ripple]: Awaited<ReturnType<typeof getRippleToolbox>>;
+  [Chain.Solana]: Awaited<ReturnType<typeof getSolanaToolbox>>;
+  [Chain.Sui]: Awaited<ReturnType<typeof getSuiToolbox>>;
+  [Chain.Ton]: Awaited<ReturnType<typeof getTONToolbox>>;
+  [Chain.Tron]: Awaited<ReturnType<typeof createTronToolbox>>;
+  [Chain.Cardano]: Awaited<ReturnType<typeof getCardanoToolbox>>;
+};
+
+type ToolboxParams = { [key in EVMChain]: Parameters<typeof getEvmToolbox>[1] } & {
+  [key in UTXOChain]: undefined;
+} & {
+  [key in CosmosChain]: Parameters<typeof getCosmosToolbox>[1];
+} & {
+  [key in SubstrateChain]: Parameters<typeof getSubstrateToolbox>[1];
+} & {
+  [Chain.Radix]: Parameters<typeof RadixToolbox>[0];
+  [Chain.Near]: Parameters<typeof getNearToolbox>[0];
+  [Chain.Ripple]: Parameters<typeof getRippleToolbox>[0];
+  [Chain.Solana]: Parameters<typeof getSolanaToolbox>[0];
+  [Chain.Sui]: Parameters<typeof getSuiToolbox>[0];
+  [Chain.Ton]: Parameters<typeof getTONToolbox>[0];
+  [Chain.Tron]: Parameters<typeof createTronToolbox>[0];
+  [Chain.Cardano]: Parameters<typeof getCardanoToolbox>[0];
+};
+
+type CreateTransactionParams = { [key in EVMChain]: EVMCreateTransactionParams } & {
+  [key in UTXOChain]: GenericCreateTransactionParams;
+} & {
+  [key in CosmosChain]: GenericCreateTransactionParams;
+} & {
+  [key in SubstrateChain]: GenericCreateTransactionParams;
+} & {
+  [Chain.Radix]: GenericCreateTransactionParams;
+  [Chain.Ripple]: GenericCreateTransactionParams;
+  [Chain.Near]: GenericCreateTransactionParams;
+  [Chain.Solana]: SolanaCreateTransactionParams;
+  [Chain.Sui]: SuiCreateTransactionParams;
+  [Chain.Ton]: GenericCreateTransactionParams;
+  [Chain.Tron]: GenericCreateTransactionParams;
+  [Chain.Cardano]: GenericCreateTransactionParams;
+};
+
+export async function getToolbox<T extends keyof Toolboxes>(
+  chain: T,
+  params?: ToolboxParams[T],
+): Promise<Toolboxes[T]> {
+  const { match } = await import("ts-pattern");
+
+  return match(chain as Chain)
+    .returnType<Promise<Toolboxes[T]>>()
+    .with(...EVMChains, async () => {
+      const { getEvmToolbox } = await import("./evm/toolbox");
+      const evmToolbox = await getEvmToolbox(chain as EVMChain, params as Parameters<typeof getEvmToolbox>[1]);
+      return evmToolbox as Toolboxes[T];
+    })
+    .with(...UTXOChains, async () => {
+      const { getUtxoToolbox } = await import("./utxo");
+      const utxoToolbox = await getUtxoToolbox(chain as UTXOChain, params as Parameters<typeof getUtxoToolbox>[1]);
+      return utxoToolbox as Toolboxes[T];
+    })
+    .with(...CosmosChains, async () => {
+      const { getCosmosToolbox } = await import("./cosmos");
+      const cosmosToolbox = await getCosmosToolbox(
+        chain as Exclude<CosmosChain, Chain.Harbor>,
+        params as Parameters<typeof getCosmosToolbox>[1],
+      );
+      return cosmosToolbox as Toolboxes[T];
+    })
+    .with(...SubstrateChains, async () => {
+      const { getSubstrateToolbox } = await import("./substrate");
+      const substrateToolbox = await getSubstrateToolbox(
+        chain as SubstrateChain,
+        params as Parameters<typeof getSubstrateToolbox>[1],
+      );
+      return substrateToolbox as Toolboxes[T];
+    })
+    .with(Chain.Radix, async () => {
+      const { RadixToolbox } = await import("./radix");
+      const radixToolbox = await RadixToolbox(params as Parameters<typeof RadixToolbox>[0]);
+      return radixToolbox as Toolboxes[T];
+    })
+    .with(Chain.Ripple, async () => {
+      const { getRippleToolbox } = await import("./ripple");
+      const rippleToolbox = await getRippleToolbox(params as Parameters<typeof getRippleToolbox>[0]);
+      return rippleToolbox as Toolboxes[T];
+    })
+    .with(Chain.Solana, async () => {
+      const { getSolanaToolbox } = await import("./solana");
+      const solanaToolbox = await getSolanaToolbox(params as Parameters<typeof getSolanaToolbox>[0]);
+      return solanaToolbox as Toolboxes[T];
+    })
+    .with(Chain.Sui, async () => {
+      const { getSuiToolbox } = await import("./sui");
+      const suiToolbox = await getSuiToolbox(params as Parameters<typeof getSuiToolbox>[0]);
+      return suiToolbox as Toolboxes[T];
+    })
+    .with(Chain.Tron, async () => {
+      const { createTronToolbox } = await import("./tron");
+      const tronToolbox = await createTronToolbox(params as Parameters<typeof createTronToolbox>[0]);
+      return tronToolbox as Toolboxes[T];
+    })
+    .with(Chain.Near, async () => {
+      const { getNearToolbox } = await import("./near");
+      const nearToolbox = await getNearToolbox(params as Parameters<typeof getNearToolbox>[0]);
+      return nearToolbox as Toolboxes[T];
+    })
+    .with(Chain.Cardano, async () => {
+      const { getCardanoToolbox } = await import("./cardano");
+      const cardanoToolbox = await getCardanoToolbox(params as Parameters<typeof getCardanoToolbox>[0]);
+      return cardanoToolbox as Toolboxes[T];
+    })
+    .with(Chain.Ton, async () => {
+      const { getTONToolbox } = await import("./ton");
+      const tonToolbox = await getTONToolbox(params as Parameters<typeof getTONToolbox>[0]);
+      return tonToolbox as Toolboxes[T];
+    })
+    .otherwise(() => {
+      throw new SwapKitError("toolbox_not_supported", { chain });
+    });
+}