@swapkit/toolboxes 4.0.0-beta.50 → 4.0.0-beta.52

package/src/evm/toolbox/evm.ts

@@ -1,66 +0,0 @@
-import { Chain, type EVMChain, FeeOption, SKConfig } from "@swapkit/helpers";
-import { HDNodeWallet } from "ethers";
-import { P, match } 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({
-      contractAddress: multicallAddress,
-      abi: multicallAbi,
-      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 GNOToolbox = createEvmToolbox(Chain.Gnosis);
-export const MATICToolbox = createEvmToolbox(Chain.Polygon);
-
-function createEvmToolbox<C extends EVMChain>(chain: C) {
-  return async function createEvmToolbox({
-    provider: providerParam,
-    ...toolboxSignerParams
-  }: EVMToolboxParams) {
-    const rpcUrl = SKConfig.get("rpcUrls")[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({ provider, signer, isEIP1559Compatible, chain });
-
-    return {
-      ...evmToolbox,
-      getNetworkParams: getNetworkParams(chain),
-      getBalance: getEvmApi(chain).getBalance,
-    };
-  };
-}

package/src/evm/toolbox/index.ts

@@ -1,52 +0,0 @@
-import { Chain, type EVMChain, SwapKitError } from "@swapkit/helpers";
-
-import { getProvider } from "../helpers";
-import type { EVMToolboxParams } from "../types";
-import {
-  ARBToolbox,
-  AURORAToolbox,
-  AVAXToolbox,
-  BASEToolbox,
-  BERAToolbox,
-  BSCToolbox,
-  ETHToolbox,
-  GNOToolbox,
-  MATICToolbox,
-} 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)),
-  };
-
-  switch (chain) {
-    case Chain.Arbitrum:
-      return ARBToolbox(toolboxParams);
-    case Chain.Aurora:
-      return AURORAToolbox(toolboxParams);
-    case Chain.Avalanche:
-      return AVAXToolbox(toolboxParams);
-    case Chain.Base:
-      return BASEToolbox(toolboxParams);
-    case Chain.Berachain:
-      return BERAToolbox(toolboxParams);
-    case Chain.BinanceSmartChain:
-      return BSCToolbox(toolboxParams);
-    case Chain.Gnosis:
-      return GNOToolbox(toolboxParams);
-    case Chain.Optimism:
-      return OPToolbox(toolboxParams);
-    case Chain.Polygon:
-      return MATICToolbox(toolboxParams);
-    case Chain.Ethereum:
-      return ETHToolbox(toolboxParams);
-    default:
-      throw new SwapKitError("toolbox_evm_not_supported", { chain });
-  }
-}
-
-export * from "./baseEVMToolbox";
-export * from "./evm";
-export * from "./op";

package/src/evm/toolbox/op.ts

@@ -1,131 +0,0 @@
-import {
-  BaseDecimal,
-  Chain,
-  ChainId,
-  ChainToExplorerUrl,
-  SKConfig,
-  SwapKitError,
-} from "@swapkit/helpers";
-import type {
-  Authorization,
-  BrowserProvider,
-  JsonRpcProvider,
-  Provider,
-  TransactionRequest,
-} from "ethers";
-import { Contract, HDNodeWallet } from "ethers";
-
-import { P } from "ts-pattern";
-import { match } 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);
-}
-
-export function getL1GasPriceFetcher<P extends Provider>(provider: P) {
-  return function getL1GasPrice() {
-    const gasPriceOracle = connectGasPriceOracle(provider);
-
-    if (gasPriceOracle && "l1BaseFee" in gasPriceOracle) {
-      return 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[],
-      to: to as string,
-      nonce: nonce ? nonce : from ? await provider.getTransactionCount(from) : 0,
-    }).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);
-  };
-}
-
-export 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);
-    }
-  };
-}
-
-const getNetworkParams = () => ({
-  chainId: ChainId.OptimismHex,
-  chainName: "Optimism",
-  nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals: BaseDecimal.ETH },
-  rpcUrls: [SKConfig.get("rpcUrls")[Chain.Optimism]],
-  blockExplorerUrls: [ChainToExplorerUrl[Chain.Optimism]],
-});
-
-export async function OPToolbox({
-  provider: providerParam,
-  ...toolboxSignerParams
-}: EVMToolboxParams) {
-  const chain = Chain.Optimism;
-  const rpcUrl = SKConfig.get("rpcUrls")[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,
-    estimateL1Gas: estimateL1Gas(provider),
-    estimateL1GasCost: estimateL1GasCost(provider),
-    estimateL2GasCost: estimateL2GasCost(provider),
-    estimateTotalGasCost: estimateTotalGasCost(provider),
-    getBalance: getEvmApi(Chain.Optimism).getBalance,
-    getL1GasPrice,
-    getNetworkParams,
-  };
-}

package/src/evm/types.ts

@@ -1,146 +0,0 @@
-import type {
-  AssetValue,
-  ChainSigner,
-  DerivationPathArray,
-  FeeOption,
-  GenericCreateTransactionParams,
-  GenericTransferParams,
-} from "@swapkit/helpers";
-import { Chain } from "@swapkit/helpers";
-import type {
-  BigNumberish,
-  BrowserProvider,
-  JsonFragment,
-  JsonRpcProvider,
-  JsonRpcSigner,
-  Signer,
-  Transaction,
-} from "ethers";
-import type {
-  ARBToolbox,
-  AURORAToolbox,
-  AVAXToolbox,
-  BASEToolbox,
-  BERAToolbox,
-  BSCToolbox,
-  ETHToolbox,
-  GNOToolbox,
-  MATICToolbox,
-  OPToolbox,
-} from "./toolbox";
-
-import type { getProvider } from "./index";
-
-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.Ethereum]: Awaited<ReturnType<typeof ETHToolbox>>;
-  [Chain.Gnosis]: Awaited<ReturnType<typeof GNOToolbox>>;
-  [Chain.Optimism]: Awaited<ReturnType<typeof OPToolbox>>;
-  [Chain.Polygon]: Awaited<ReturnType<typeof MATICToolbox>>;
-};

package/src/index.ts

@@ -1,263 +0,0 @@
-import {
-  AssetValue,
-  Chain,
-  type CosmosChain,
-  type EVMChain,
-  FeeOption,
-  type GenericCreateTransactionParams,
-  type SubstrateChain,
-  SwapKitError,
-  type UTXOChain,
-} from "@swapkit/helpers";
-import type { getCosmosToolbox } from "@swapkit/toolboxes/cosmos";
-
-import type { ETHToolbox, EVMCreateTransactionParams, getEvmToolbox } from "@swapkit/toolboxes/evm";
-import type { getNearToolbox } from "@swapkit/toolboxes/near";
-import type { RadixToolbox } from "@swapkit/toolboxes/radix";
-import type { getRippleToolbox } from "@swapkit/toolboxes/ripple";
-import type { SolanaCreateTransactionParams, getSolanaToolbox } from "@swapkit/toolboxes/solana";
-import type { getSubstrateToolbox } from "@swapkit/toolboxes/substrate";
-import type { createTronToolbox } from "@swapkit/toolboxes/tron";
-import type { getUtxoToolbox } from "@swapkit/toolboxes/utxo";
-
-export async function getAddressValidator() {
-  const { match } = await import("ts-pattern");
-  const { cosmosValidateAddress } = await import("@swapkit/toolboxes/cosmos");
-  const { evmValidateAddress } = await import("@swapkit/toolboxes/evm");
-  const { substrateValidateAddress } = await import("@swapkit/toolboxes/substrate");
-  const { getUTXOAddressValidator } = await import("@swapkit/toolboxes/utxo");
-  const { getSolanaAddressValidator } = await import("@swapkit/toolboxes/solana");
-  const { getValidateNearAddress } = await import("@swapkit/toolboxes/near");
-  const { rippleValidateAddress } = await import("@swapkit/toolboxes/ripple");
-  const { radixValidateAddress } = await import("@swapkit/toolboxes/radix");
-  const { getTronAddressValidator } = await import("@swapkit/toolboxes/tron");
-
-  const solanaValidateAddress = await getSolanaAddressValidator();
-  const utxoValidateAddress = await getUTXOAddressValidator();
-  const tronValidateAddress = await getTronAddressValidator();
-  const nearValidateAddress = await getValidateNearAddress();
-
-  return function validateAddress({ address, chain }: { address: string; chain: Chain }) {
-    const isValid = match(chain)
-      .with(
-        Chain.Arbitrum,
-        Chain.Aurora,
-        Chain.Avalanche,
-        Chain.Base,
-        Chain.Berachain,
-        Chain.BinanceSmartChain,
-        Chain.Ethereum,
-        Chain.Gnosis,
-        Chain.Optimism,
-        Chain.Polygon,
-        () => evmValidateAddress({ address }),
-      )
-      .with(Chain.Litecoin, Chain.Dash, Chain.Dogecoin, Chain.BitcoinCash, Chain.Bitcoin, () =>
-        utxoValidateAddress({ address, chain: chain as UTXOChain }),
-      )
-      .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, () =>
-        cosmosValidateAddress({ address, chain: chain as CosmosChain }),
-      )
-      .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.Tron, () => tronValidateAddress(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(
-        Chain.Arbitrum,
-        Chain.Aurora,
-        Chain.Avalanche,
-        Chain.Base,
-        Chain.Berachain,
-        Chain.BinanceSmartChain,
-        Chain.Ethereum,
-        Chain.Gnosis,
-        Chain.Optimism,
-        Chain.Polygon,
-        async (chain) => {
-          const toolbox = await getToolbox(chain);
-          const txObject = await toolbox.createTransaction(params);
-
-          return (toolbox as Awaited<ReturnType<typeof ETHToolbox>>).estimateTransactionFee({
-            ...txObject,
-            feeOption: params.feeOptionKey || FeeOption.Fast,
-            chain,
-          });
-        },
-      )
-      .with(
-        Chain.Bitcoin,
-        Chain.BitcoinCash,
-        Chain.Dogecoin,
-        Chain.Dash,
-        Chain.Litecoin,
-        Chain.Polkadot,
-        Chain.Solana,
-        Chain.Ripple,
-        Chain.Tron,
-        Chain.Near,
-        async (chain) => {
-          const toolbox = await getToolbox(chain);
-          return toolbox.estimateTransactionFee(params) as Promise<AssetValue>;
-        },
-      )
-      .with(Chain.THORChain, Chain.Maya, Chain.Kujira, Chain.Cosmos, async () => {
-        const { estimateTransactionFee } = await import("@swapkit/toolboxes/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.Tron]: Awaited<ReturnType<typeof createTronToolbox>>;
-};
-
-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.Tron]: Parameters<typeof createTronToolbox>[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.Tron]: 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(
-      Chain.Arbitrum,
-      Chain.Aurora,
-      Chain.Avalanche,
-      Chain.Base,
-      Chain.Berachain,
-      Chain.BinanceSmartChain,
-      Chain.Ethereum,
-      Chain.Gnosis,
-      Chain.Optimism,
-      Chain.Polygon,
-      async () => {
-        const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-        const evmToolbox = await getEvmToolbox(
-          chain as EVMChain,
-          params as Parameters<typeof getEvmToolbox>[1],
-        );
-        return evmToolbox as Toolboxes[T];
-      },
-    )
-    .with(
-      Chain.Litecoin,
-      Chain.Dash,
-      Chain.Dogecoin,
-      Chain.BitcoinCash,
-      Chain.Bitcoin,
-      Chain.Zcash,
-      async () => {
-        const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-        const utxoToolbox = await getUtxoToolbox(
-          chain as UTXOChain,
-          params as Parameters<typeof getUtxoToolbox>[1],
-        );
-        return utxoToolbox as Toolboxes[T];
-      },
-    )
-    .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, async () => {
-      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
-      const cosmosToolbox = await getCosmosToolbox(
-        chain as CosmosChain,
-        params as Parameters<typeof getCosmosToolbox>[1],
-      );
-      return cosmosToolbox as Toolboxes[T];
-    })
-    .with(Chain.Chainflip, Chain.Polkadot, async () => {
-      const { getSubstrateToolbox } = await import("@swapkit/toolboxes/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("@swapkit/toolboxes/radix");
-      const radixToolbox = await RadixToolbox(params as Parameters<typeof RadixToolbox>[0]);
-      return radixToolbox as Toolboxes[T];
-    })
-    .with(Chain.Ripple, async () => {
-      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
-      const rippleToolbox = await getRippleToolbox(
-        params as Parameters<typeof getRippleToolbox>[0],
-      );
-      return rippleToolbox as Toolboxes[T];
-    })
-    .with(Chain.Solana, async () => {
-      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
-      const solanaToolbox = await getSolanaToolbox(
-        params as Parameters<typeof getSolanaToolbox>[0],
-      );
-      return solanaToolbox as Toolboxes[T];
-    })
-    .with(Chain.Tron, async () => {
-      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
-      const tronToolbox = await createTronToolbox(params);
-      return tronToolbox as Toolboxes[T];
-    })
-    .with(Chain.Near, async () => {
-      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
-      const nearToolbox = await getNearToolbox(params as Parameters<typeof getNearToolbox>[0]);
-      return nearToolbox as Toolboxes[T];
-    })
-    .otherwise(() => {
-      throw new SwapKitError("toolbox_not_supported", { chain });
-    });
-}