@swapkit/toolboxes 1.0.0-beta.9 → 4.0.0-beta.35

package/src/evm/__tests__/address-validation.test.ts

@@ -0,0 +1,86 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@swapkit/helpers";
+import { getEvmToolbox } from "../toolbox";
+
+const context: {
+  validateAddress: (address: string) => boolean;
+} = {} as any;
+
+beforeAll(async () => {
+  // Get EVM toolbox for address validation
+  const toolbox = await getEvmToolbox(Chain.Ethereum);
+  context.validateAddress = toolbox.validateAddress;
+});
+
+describe("EVM Address Validation", () => {
+  test("should validate valid EVM addresses", () => {
+    const validAddresses = [
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114B", // User provided address
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC contract
+      "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6", // Test address
+      "0xE29E61479420Dd1029A9946710Ac31A0d140e77F", // Another valid address
+      "0x0000000000000000000000000000000000000000", // Zero address
+      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF", // Max address
+      "0x1234567890123456789012345678901234567890", // Mixed case
+    ];
+
+    for (const address of validAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid EVM addresses", () => {
+    const invalidAddresses = [
+      "", // Empty string
+      "invalid", // Random string
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", // TRON address
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", // Bitcoin address
+      "cosmos1abc123", // Cosmos address
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114", // Too short (missing 1 char)
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114BB", // Too long (extra char)
+      "0XA052DDF1C1739419B90FB7BF722843AD3E63114B", // Uppercase 0X prefix
+      "0xG052Ddf1c1739419B90FB7bf722843AD3e63114B", // Invalid hex character
+      "0x", // Only prefix
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should handle case normalization properly", () => {
+    const address = "0xa052Ddf1c1739419B90FB7bf722843AD3e63114B"; // Proper checksum
+    const lowerCase = address.toLowerCase();
+
+    // Valid case variations should be accepted
+    expect(context.validateAddress(address)).toBe(true);
+    expect(context.validateAddress(lowerCase)).toBe(true);
+  });
+
+  test("should reject invalid checksum addresses", () => {
+    const invalidChecksumAddress = "0xA052dDF1C1739419b90fb7BF722843ad3E63114b"; // Invalid checksum
+
+    // Should reject mixed case with invalid checksum
+    expect(context.validateAddress(invalidChecksumAddress)).toBe(false);
+  });
+
+  test("should handle edge cases", () => {
+    const edgeCases = [null, undefined, 123, {}, [], true, false];
+
+    for (const testCase of edgeCases) {
+      // Should not throw but return false for invalid inputs
+      expect(context.validateAddress(testCase as any)).toBe(false);
+    }
+  });
+
+  test("should validate checksummed addresses", () => {
+    const checksummedAddresses = [
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC with proper checksum
+      "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6", // Another checksummed address
+    ];
+
+    for (const address of checksummedAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+    }
+  });
+});

package/src/evm/__tests__/ethereum.test.ts

@@ -35,7 +35,7 @@ beforeEach(async () => {
     },
   });
   context.provider = provider;
-  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer });
+  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer: signer as any });
 });
 
 afterEach(async () => {

package/src/evm/helpers.ts

@@ -8,6 +8,7 @@ import {
   FeeOption,
   type NetworkParams,
   SKConfig,
+  SwapKitError,
   SwapKitNumber,
 } from "@swapkit/helpers";
 import type { BrowserProvider, Provider } from "ethers";
@@ -71,7 +72,7 @@ export const estimateMaxSendableAmount = async ({
   const isFeeEVMLegacyCompatible = "gasPrice" in gasRate && gasRate.gasPrice !== undefined;
 
   if (!(gasRate && (isFeeEVMLegacyCompatible || isFeeEIP1559Compatible))) {
-    throw new Error("Could not fetch fee data");
+    throw new SwapKitError("toolbox_evm_no_fee_data");
   }
 
   const gasPrice = isFeeEIP1559Compatible
@@ -116,7 +117,7 @@ export function getEstimateTransactionFee({
       return assetValue.set(SwapKitNumber.fromBigInt(fee, assetValue.decimal));
     }
 
-    throw new Error("No gas price found");
+    throw new SwapKitError("toolbox_evm_no_gas_price");
   };
 }
 
@@ -168,6 +169,6 @@ function getNetworkInfo<C extends EVMChain>({ chain }: { chain: C }) {
         nativeCurrency: { name: "Polygon", symbol: Chain.Polygon, decimals },
       };
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_evm_not_supported", { chain });
   }
 }

package/src/evm/toolbox/baseEVMToolbox.ts

@@ -8,6 +8,7 @@ import {
   FeeOption,
   SwapKitError,
   SwapKitNumber,
+  applyFeeMultiplierToBigInt,
   isGasAsset,
 } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
@@ -208,7 +209,7 @@ export function getEstimateGasPrices({
       try {
         const { gasPrice } = await provider.getFeeData();
 
-        if (!gasPrice) throw new Error("No fee data available");
+        if (!gasPrice) throw new SwapKitError("toolbox_evm_no_fee_data");
 
         return {
           [FeeOption.Average]: { gasPrice },
@@ -216,9 +217,9 @@ export function getEstimateGasPrices({
           [FeeOption.Fastest]: { gasPrice },
         };
       } catch (error) {
-        throw new Error(
-          `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-        );
+        throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+          error: (error as any).msg ?? (error as any).toString(),
+        });
       }
     };
   }
@@ -231,7 +232,7 @@ export function getEstimateGasPrices({
         const price = gasPrice as bigint;
 
         if (!(maxFeePerGas && maxPriorityFeePerGas)) {
-          throw new Error("No fee data available");
+          throw new SwapKitError("toolbox_evm_no_fee_data");
         }
 
         return {
@@ -242,22 +243,25 @@ export function getEstimateGasPrices({
             maxPriorityFeePerGas,
           },
           [FeeOption.Fast]: {
-            l1GasPrice: ((l1GasPrice || 0n) * 15n) / 10n,
-            gasPrice: (price * 15n) / 10n,
+            l1GasPrice: applyFeeMultiplierToBigInt(l1GasPrice || 0n, FeeOption.Fast),
+            gasPrice: applyFeeMultiplierToBigInt(price, FeeOption.Fast),
             maxFeePerGas,
-            maxPriorityFeePerGas: (maxPriorityFeePerGas * 15n) / 10n,
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(maxPriorityFeePerGas, FeeOption.Fast),
           },
           [FeeOption.Fastest]: {
-            l1GasPrice: (l1GasPrice || 0n) * 2n,
-            gasPrice: price * 2n,
+            l1GasPrice: applyFeeMultiplierToBigInt(l1GasPrice || 0n, FeeOption.Fastest),
+            gasPrice: applyFeeMultiplierToBigInt(price, FeeOption.Fastest),
             maxFeePerGas,
-            maxPriorityFeePerGas: maxPriorityFeePerGas * 2n,
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(
+              maxPriorityFeePerGas,
+              FeeOption.Fastest,
+            ),
           },
         };
       } catch (error) {
-        throw new Error(
-          `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-        );
+        throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+          error: (error as any).msg ?? (error as any).toString(),
+        });
       }
     };
   }
@@ -273,12 +277,15 @@ export function getEstimateGasPrices({
         return {
           [FeeOption.Average]: { maxFeePerGas, maxPriorityFeePerGas },
           [FeeOption.Fast]: {
-            maxFeePerGas: (maxFeePerGas * 15n) / 10n,
-            maxPriorityFeePerGas: (maxPriorityFeePerGas * 15n) / 10n,
+            maxFeePerGas: applyFeeMultiplierToBigInt(maxFeePerGas, FeeOption.Fast),
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(maxPriorityFeePerGas, FeeOption.Fast),
           },
           [FeeOption.Fastest]: {
-            maxFeePerGas: maxFeePerGas * 2n,
-            maxPriorityFeePerGas: maxPriorityFeePerGas * 2n,
+            maxFeePerGas: applyFeeMultiplierToBigInt(maxFeePerGas, FeeOption.Fastest),
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(
+              maxPriorityFeePerGas,
+              FeeOption.Fastest,
+            ),
           },
         };
       }
@@ -286,13 +293,13 @@ export function getEstimateGasPrices({
 
       return {
         [FeeOption.Average]: { gasPrice },
-        [FeeOption.Fast]: { gasPrice: (gasPrice * 15n) / 10n },
-        [FeeOption.Fastest]: { gasPrice: gasPrice * 2n },
+        [FeeOption.Fast]: { gasPrice: applyFeeMultiplierToBigInt(gasPrice, FeeOption.Fast) },
+        [FeeOption.Fastest]: { gasPrice: applyFeeMultiplierToBigInt(gasPrice, FeeOption.Fastest) },
       };
     } catch (error) {
-      throw new Error(
-        `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-      );
+      throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+        error: (error as any).msg ?? (error as any).toString(),
+      });
     }
   };
 }
@@ -314,7 +321,10 @@ function getCall({ provider, isEIP1559Compatible, signer, chain }: ToolboxWrapPa
     feeOption = FeeOption.Fast,
   }: CallParams): Promise<T> {
     const contractProvider = callProvider || provider;
-    if (!contractAddress) throw new Error("contractAddress must be provided");
+    if (!contractAddress)
+      throw new SwapKitError("toolbox_evm_invalid_params", {
+        error: "contractAddress must be provided",
+      });
 
     const isStateChanging = isStateChangingCall({ abi, funcName });
 

package/src/evm/toolbox/index.ts

@@ -1,4 +1,4 @@
-import { Chain, type EVMChain } from "@swapkit/helpers";
+import { Chain, type EVMChain, SwapKitError } from "@swapkit/helpers";
 
 import { getProvider } from "../helpers";
 import type { EVMToolboxParams } from "../types";
@@ -27,7 +27,7 @@ export async function getEvmToolbox<T extends EVMChain>(chain: T, params?: EVMTo
     case Chain.Ethereum:
       return ETHToolbox(toolboxParams);
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_evm_not_supported", { chain });
   }
 }
 

package/src/evm/toolbox/op.ts

@@ -1,5 +1,18 @@
-import { BaseDecimal, Chain, ChainId, ChainToExplorerUrl, SKConfig } from "@swapkit/helpers";
-import type { BrowserProvider, JsonRpcProvider, Provider, TransactionRequest } from "ethers";
+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";
@@ -32,14 +45,15 @@ 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 Error("Missing to address");
-    const txParams = {
+    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,
-    };
-
-    return Transaction.from(txParams).serialized;
+    }).serialized;
   };
 }
 

package/src/index.ts

@@ -6,15 +6,18 @@ import {
   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() {
@@ -24,11 +27,14 @@ export async function getAddressValidator() {
   const { substrateValidateAddress } = await import("@swapkit/toolboxes/substrate");
   const { getUTXOAddressValidator } = await import("@swapkit/toolboxes/utxo");
   const { getSolanaAddressValidator } = await import("@swapkit/toolboxes/solana");
+  const { validateNearAddress } = 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();
 
   return function validateAddress({ address, chain }: { address: string; chain: Chain }) {
     const isValid = match(chain)
@@ -52,68 +58,62 @@ export async function getAddressValidator() {
         substrateValidateAddress({ address, chain: chain as SubstrateChain }),
       )
       .with(Chain.Radix, () => radixValidateAddress(address))
+      .with(Chain.Near, () => validateNearAddress(address))
       .with(Chain.Ripple, () => rippleValidateAddress(address))
       .with(Chain.Solana, () => solanaValidateAddress(address))
+      .with(Chain.Tron, () => tronValidateAddress(address))
       .otherwise(() => false);
 
     return isValid;
   };
 }
 
-export async function getFeeEstimator<T extends keyof CreateTransactionParams>(chain: T) {
-  const toolbox = await getToolbox(chain);
-
+export function getFeeEstimator<T extends keyof CreateTransactionParams>(chain: T) {
   return async function estimateFee(params: CreateTransactionParams[T]) {
-    switch (chain) {
-      case Chain.Arbitrum:
-      case Chain.Avalanche:
-      case Chain.Optimism:
-      case Chain.BinanceSmartChain:
-      case Chain.Base:
-      case Chain.Polygon:
-      case Chain.Ethereum: {
-        const txObject = await (
-          toolbox as Awaited<ReturnType<typeof ETHToolbox>>
-        ).createTransaction(params as EVMCreateTransactionParams);
-        return (toolbox as Awaited<ReturnType<typeof ETHToolbox>>).estimateTransactionFee({
-          ...txObject,
-          feeOption: params.feeOptionKey || FeeOption.Fast,
-          chain,
-        });
-      }
-      case Chain.Bitcoin:
-      case Chain.BitcoinCash:
-      case Chain.Dogecoin:
-      case Chain.Dash:
-      case Chain.Litecoin: {
-        return (toolbox as Awaited<ReturnType<typeof getUtxoToolbox>>).estimateTransactionFee(
-          params as CreateTransactionParams[Chain.Bitcoin],
-        );
-      }
+    const { match } = await import("ts-pattern");
 
-      case Chain.THORChain:
-      case Chain.Maya:
-      case Chain.Kujira:
-      case Chain.Cosmos: {
+    return match(chain as Chain)
+      .returnType<Promise<AssetValue>>()
+      .with(
+        Chain.Arbitrum,
+        Chain.Avalanche,
+        Chain.Optimism,
+        Chain.BinanceSmartChain,
+        Chain.Base,
+        Chain.Polygon,
+        Chain.Ethereum,
+        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);
-      }
-
-      case Chain.Polkadot: {
-        return (
-          toolbox as Awaited<ReturnType<typeof getSubstrateToolbox<Chain.Polkadot>>>
-        ).estimateTransactionFee(params);
-      }
-
-      case Chain.Solana: {
-        return (toolbox as Awaited<ReturnType<typeof getSolanaToolbox>>).estimateTransactionFee(
-          params as CreateTransactionParams[Chain.Solana],
-        );
-      }
-
-      default:
-        return AssetValue.from({ chain });
-    }
+      })
+      .otherwise(async () => AssetValue.from({ chain }));
   };
 }
 
@@ -127,8 +127,10 @@ type Toolboxes = {
   [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] } & {
@@ -139,8 +141,10 @@ type ToolboxParams = { [key in EVMChain]: Parameters<typeof getEvmToolbox>[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 } & {
@@ -151,85 +155,99 @@ type CreateTransactionParams = { [key in EVMChain]: EVMCreateTransactionParams }
   [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]> {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.Optimism:
-    case Chain.BinanceSmartChain:
-    case Chain.Base:
-    case Chain.Polygon:
-    case Chain.Ethereum: {
-      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-      const evmToolbox = await getEvmToolbox(chain, params as Parameters<typeof getEvmToolbox>[1]);
-      return evmToolbox as Toolboxes[T];
-    }
-
-    case Chain.Litecoin:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.BitcoinCash:
-    case Chain.Bitcoin: {
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const utxoToolbox = await getUtxoToolbox(
-        chain,
-        params as Parameters<typeof getUtxoToolbox>[1],
-      );
-      return utxoToolbox as Toolboxes[T];
-    }
+  const { match } = await import("ts-pattern");
 
-    case Chain.Cosmos:
-    case Chain.Kujira:
-    case Chain.Maya:
-    case Chain.THORChain: {
+  return match(chain as Chain)
+    .returnType<Promise<Toolboxes[T]>>()
+    .with(
+      Chain.Arbitrum,
+      Chain.Avalanche,
+      Chain.Optimism,
+      Chain.BinanceSmartChain,
+      Chain.Base,
+      Chain.Polygon,
+      Chain.Ethereum,
+      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,
+        chain as CosmosChain,
         params as Parameters<typeof getCosmosToolbox>[1],
       );
-
       return cosmosToolbox as Toolboxes[T];
-    }
-
-    case Chain.Chainflip:
-    case Chain.Polkadot: {
+    })
+    .with(Chain.Chainflip, Chain.Polkadot, async () => {
       const { getSubstrateToolbox } = await import("@swapkit/toolboxes/substrate");
       const substrateToolbox = await getSubstrateToolbox(
-        chain,
+        chain as SubstrateChain,
         params as Parameters<typeof getSubstrateToolbox>[1],
       );
       return substrateToolbox as Toolboxes[T];
-    }
-
-    case Chain.Radix: {
+    })
+    .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];
-    }
-
-    case Chain.Ripple: {
+    })
+    .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];
-    }
-
-    case Chain.Solana: {
+    })
+    .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];
-    }
-
-    default:
-      throw new Error(`Chain ${chain} is not supported`);
-  }
+    })
+    .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 });
+    });
 }