@swapkit/toolboxes 1.0.0-beta.0 → 1.0.0-beta.1

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

@@ -1,147 +1,141 @@
 import { afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import type ethers from "@nomicfoundation/hardhat-ethers";
-import { AssetValue, Chain, FeeOption } from "@swapkit/helpers";
+import helpers from "@nomicfoundation/hardhat-network-helpers";
+import { AssetValue, Chain, SKConfig } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
 import type { JsonRpcProvider } from "ethers";
-// import hre from "hardhat";
+import hre from "hardhat";
+import { getProvider } from "../helpers";
+import { getEvmToolbox } from "../toolbox";
 
-import type { ETHToolbox } from "../index";
 const testAddress = "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6";
 const emptyRecipient = "0xE29E61479420Dd1029A9946710Ac31A0d140e77F";
 const USDCAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
 // Get latest block to use as base for reset fork after test
-// const _block = await hre.ethers.provider.getBlock("latest");
+const block = await hre.ethers.provider.getBlock("latest");
 
 beforeAll(() => {
-  // hre.run("node");
+  hre.run("node");
 });
 
 const context: {
   ethers: typeof ethers;
   provider: JsonRpcProvider;
-  toolbox: ReturnType<typeof ETHToolbox>;
+  toolbox: Awaited<ReturnType<typeof getEvmToolbox>>;
 } = {} as any;
 
 beforeEach(async () => {
-  // context.ethers = hre.artifacts;
-  // const provider = getProvider(Chain.Ethereum, "http://127.0.0.1:8545/");
-  // const signer = (await hre.ethers.getImpersonatedSigner(testAddress)) as unknown as JsonRpcSigner;
-  // context.provider = provider;
-  // context.toolbox = ETHToolbox({ provider, signer });
+  context.ethers = hre.artifacts;
+  const provider = await getProvider(Chain.Ethereum, "http://127.0.0.1:8545/");
+  const signer = await hre.ethers.getImpersonatedSigner(testAddress);
+
+  SKConfig.set({
+    apiKeys: {
+      swapKit: process.env.TEST_API_KEY || Bun.env.TEST_API_KEY,
+    },
+  });
+  context.provider = provider;
+  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer });
 });
 
 afterEach(async () => {
-  // await helpers.reset(hre.config.networks.hardhat.forking?.url, block?.number);
+  await helpers.reset(hre.config.networks.hardhat.forking?.url, block?.number);
 });
 
 describe("Ethereum toolkit", () => {
-  test.todo(
-    "Get Balances",
-    async () => {
-      const balances = await context.toolbox.getBalance(testAddress);
-      expect(balances.find((balance) => balance.symbol === "ETH")?.getBaseValue("string")).toBe(
-        "20526000000000000",
-      );
-      expect(
-        balances
-          .find(
-            (balance) =>
-              balance.symbol.toLowerCase() ===
-              "USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase(),
-          )
-          ?.getBaseValue("string"),
-      ).toBe("6656178");
-    },
-    10000,
-  );
-
-  test.todo(
-    "Send ETH",
-    async () => {
-      expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe("0");
-      await context.toolbox.transfer({
-        recipient: emptyRecipient,
-        assetValue: await AssetValue.from({ chain: Chain.Ethereum, value: "0.010526" }),
-        from: testAddress,
-      });
-      expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe(
-        "10526000000000000",
-      );
-    },
-    10000,
-  );
-
-  test.todo(
-    "Send Token",
-    async () => {
-      const USDC = await context.toolbox.createContract(USDCAddress, erc20ABI, context.provider);
-      const balance = await USDC.balanceOf?.(emptyRecipient);
-      expect(balance.toString()).toBe("0");
-      await context.toolbox.transfer({
-        recipient: emptyRecipient,
-        assetValue: await AssetValue.from({
-          asset: "ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-          value: "1",
-        }),
+  // biome-ignore lint/suspicious/noSkippedTests: env not setup correctly
+  test.skip("Get Balances", async () => {
+    const balances = await context.toolbox.getBalance(testAddress);
+    expect(balances.find((balance) => balance.symbol === "ETH")?.getBaseValue("string")).toBe(
+      "20526000000000000",
+    );
+    expect(
+      balances
+        .find(
+          (balance) =>
+            balance.symbol.toLowerCase() ===
+            "USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase(),
+        )
+        ?.getBaseValue("string"),
+    ).toBe("6656178");
+  }, 10000);
+
+  test("Send ETH", async () => {
+    expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe("0");
+    await context.toolbox.transfer({
+      recipient: emptyRecipient,
+      assetValue: await AssetValue.from({ chain: Chain.Ethereum, value: "0.010526" }),
+      sender: testAddress,
+    });
+    expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe(
+      "10526000000000000",
+    );
+  }, 10000);
+
+  test("Send Token", async () => {
+    const USDC = await context.toolbox.createContract(USDCAddress, erc20ABI);
+    const balance = await USDC.balanceOf?.(emptyRecipient);
+    expect(balance.toString()).toBe("0");
+
+    await AssetValue.loadStaticAssets(["thorchain"]);
+
+    const assetValue = AssetValue.from({
+      asset: "ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      value: "1",
+    });
+
+    await context.toolbox.transfer({
+      recipient: emptyRecipient,
+      assetValue,
+      sender: testAddress,
+    });
+    // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
+    expect((await USDC.balanceOf?.(emptyRecipient)).toString()).toBe("1000000");
+  }, 10000);
+
+  test("Approve Token and validate approved amount", async () => {
+    expect(
+      await context.toolbox.isApproved({
+        assetAddress: USDCAddress,
+        spenderAddress: emptyRecipient,
         from: testAddress,
-      });
-      // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
-      expect((await USDC.balanceOf?.(emptyRecipient)).toString()).toBe("1000000");
-    },
-    10000,
-  );
-
-  test.todo(
-    "Approve Token and validate approved amount",
-    async () => {
-      expect(
-        await context.toolbox.isApproved({
-          assetAddress: USDCAddress,
-          spenderAddress: emptyRecipient,
-          from: testAddress,
-          amount: "1000000",
-        }),
-      ).toBe(false);
-      await context.toolbox.approve({
+        amount: "1000000",
+      }),
+    ).toBe(false);
+
+    await context.toolbox.approve({
+      assetAddress: USDCAddress,
+      spenderAddress: emptyRecipient,
+      amount: "1000000",
+    });
+
+    expect(
+      await context.toolbox.isApproved({
         assetAddress: USDCAddress,
         spenderAddress: emptyRecipient,
+        from: testAddress,
         amount: "1000000",
+      }),
+    ).toBe(true);
+  }, 10000);
+
+  test("Create contract tx object and sendTransaction", async () => {
+    const USDC = context.toolbox.createContract(USDCAddress, erc20ABI);
+    const balance = await USDC.balanceOf?.(emptyRecipient);
+    expect(balance.toString()).toBe("0");
+
+    const txObject = await context.toolbox.createContractTxObject({
+      contractAddress: USDCAddress,
+      abi: erc20ABI,
+      funcName: "transfer",
+      funcParams: [emptyRecipient, BigInt("2222222")],
+      txOverrides: {
         from: testAddress,
-      });
-
-      expect(
-        await context.toolbox.isApproved({
-          assetAddress: USDCAddress,
-          spenderAddress: emptyRecipient,
-          from: testAddress,
-          amount: "1000000",
-        }),
-      ).toBe(true);
-    },
-    10000,
-  );
-
-  test.todo(
-    "Create contract tx object and sendTransaction",
-    async () => {
-      const USDC = context.toolbox.createContract(USDCAddress, erc20ABI, context.provider);
-      const balance = await USDC.balanceOf?.(emptyRecipient);
-      expect(balance.toString()).toBe("0");
-
-      const txObject = await context.toolbox.createContractTxObject({
-        contractAddress: USDCAddress,
-        abi: erc20ABI,
-        funcName: "transfer",
-        funcParams: [emptyRecipient, BigInt("2222222")],
-        txOverrides: {
-          from: testAddress,
-        },
-      });
-
-      await context.toolbox.sendTransaction(txObject, FeeOption.Average);
-      // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
-      expect((await USDC?.balanceOf?.(emptyRecipient)).toString()).toBe("2222222");
-    },
-    10000,
-  );
+      },
+    });
+
+    await context.toolbox.sendTransaction(txObject);
+    // biome-ignore lint/correctness/noUnsafeOptionalChaining: <explanation>
+    expect((await USDC?.balanceOf?.(emptyRecipient)).toString()).toBe("2222222");
+  }, 10000);
 });

package/src/evm/api.ts

@@ -1,157 +1,21 @@
-import {
-  Chain,
-  ChainToChainId,
-  type EVMChain,
-  RequestClient,
-  SKConfig,
-  formatBigIntToSafeValue,
-  warnOnce,
-} from "@swapkit/helpers";
+import { type EVMChain, SKConfig, warnOnce } from "@swapkit/helpers";
+import { getBalance } from "../utils";
 
-async function getEthplorerBalance({ address }: { address: string }) {
-  const apiKey = SKConfig.get("apiKeys").ethplorer || "freekey";
-
-  const { tokens = [] } = await RequestClient.get<AddressInfo>(
-    `https://api.ethplorer.io/getAddressInfo/${address}`,
-    { searchParams: { apiKey } },
-  );
-
-  return tokens
-    .filter(({ tokenInfo: { symbol }, rawBalance }) => symbol && rawBalance !== "0")
-    .map(({ tokenInfo: { symbol, decimals, address: tokenAddress }, rawBalance }) => ({
-      chain: Chain.Ethereum,
-      decimal: Number.parseInt(decimals),
-      symbol: tokenAddress ? `${symbol}-${tokenAddress}` : symbol,
-      value: formatBigIntToSafeValue({
-        value: BigInt(rawBalance),
-        decimal: Number.parseInt(decimals),
-        bigIntDecimal: Number.parseInt(decimals),
-      }),
-    }));
-}
-
-async function getCovalentBalance({ chain, address }: { chain: Chain; address: string }) {
-  const apiKey = SKConfig.get("apiKeys").covalent;
+export function getEvmApi(chain: EVMChain) {
+  const customEvmApi = SKConfig.get("apis")[chain];
 
-  if (!apiKey) {
-    warnOnce(true, "No covalent api key found. Use SKConfig.setApiKey('your-api-key')");
-    return [];
+  if (customEvmApi) {
+    warnOnce(true, "Using custom EVM API. Be sure to implement all methods to avoid issues.");
+    return customEvmApi as ReturnType<typeof evmApi>;
   }
 
-  const { data } = await RequestClient.get<{ data: CovalentBalanceResponse }>(
-    `https://api.covalenthq.com/v1/${ChainToChainId[chain]}/address/${address}/balances_v2/`,
-    { searchParams: { key: apiKey } },
-  );
-
-  return (data?.items || [])
-    .filter(({ is_spam }) => !is_spam)
-    .map(
-      ({ balance, contract_decimals, contract_ticker_symbol, contract_address, native_token }) => ({
-        value: formatBigIntToSafeValue({
-          value: BigInt(balance),
-          decimal: contract_decimals,
-          bigIntDecimal: contract_decimals,
-        }),
-        decimal: contract_decimals,
-        chain,
-        symbol: `${contract_ticker_symbol || "Unknown"}${native_token ? "" : `-${contract_address}`}`,
-      }),
-    );
-}
-
-export function getEvmApi(chain: EVMChain) {
-  const getBalance = chain === Chain.Ethereum ? getEthplorerBalance : getCovalentBalance;
-  return { getBalance: (address: string) => getBalance({ address, chain }) };
+  return evmApi(chain);
 }
 
 export function createCustomEvmApi(methods: ReturnType<typeof getEvmApi>) {
   return methods;
 }
 
-type CovalentBalanceResponse = {
-  address: string;
-  updated_at: string;
-  next_updated_at: string;
-  quote_currency: string;
-  items: {
-    is_spam: boolean;
-    contract_decimals: number;
-    contract_name: string;
-    contract_ticker_symbol: string;
-    contract_address: string;
-    logo_url: string;
-    last_transferred_at: string;
-    native_token: boolean;
-    type: string;
-    balance: number;
-    balance_24h: number;
-    quote_rate: number;
-    quote_rate_24h: number;
-    quote: number;
-    quote_24h: number;
-  }[];
-};
-
-type PriceInfo = {
-  rate: number;
-  diff: number;
-  diff7d?: number;
-  ts: number;
-  marketCapUsd?: number;
-  availableSupply?: number;
-  volume24h?: number;
-  diff30d?: number;
-  volDiff1?: number;
-  volDiff7?: number;
-  volDiff30?: number;
-  currency?: string;
-};
-
-type TokenInfo = {
-  address: string;
-  decimals: string;
-  name: string;
-  owner: string;
-  symbol: string;
-  totalSupply: string;
-  lastUpdated: number;
-  issuancesCount: number;
-  holdersCount: number;
-  image?: string;
-  description?: string;
-  website?: string;
-  twitter?: string;
-  facebook?: string;
-  coingecko?: string;
-  ethTransfersCount: number;
-  price: boolean | PriceInfo | unknown;
-  publicTags?: string[];
-  txsCount?: number;
-  transfersCount?: number;
-};
-
-type TokenBalance = {
-  tokenInfo: TokenInfo;
-  balance: number;
-  rawBalance: string;
-  totalIn?: number;
-  totalOut?: number;
-};
-
-export type AddressInfo = {
-  address: string;
-  ETH: {
-    balance: number;
-    totalIn?: number;
-    totalOut?: number;
-    price: PriceInfo;
-  };
-  contractInfo?: {
-    creatorAddress: string;
-    transactionHash: string;
-    timestamp: string;
-  };
-  tokenInfo?: TokenInfo;
-  tokens?: TokenBalance[];
-  countTxs: number;
-};
+function evmApi(chain: EVMChain) {
+  return { getBalance: getBalance(chain) };
+}

package/src/evm/helpers.ts

@@ -1,20 +1,30 @@
 import {
   AssetValue,
   BaseDecimal,
+  Chain,
+  ChainToExplorerUrl,
+  ChainToHexChainId,
   type EVMChain,
   FeeOption,
+  type NetworkParams,
+  SKConfig,
   SwapKitNumber,
-  filterAssets,
-  formatBigIntToSafeValue,
-  isGasAsset,
 } from "@swapkit/helpers";
-import type { BrowserProvider, JsonRpcProvider, Provider } from "ethers";
+import type { BrowserProvider, Provider } from "ethers";
 
-import { getEvmApi } from "./api";
-import { type EIP1559TxParams, type EVMMaxSendableAmountsParams, estimateGasPrices } from "./index";
+import { getEstimateGasPrices } from "./toolbox/baseEVMToolbox";
+import type { EIP1559TxParams, EVMMaxSendableAmountsParams } from "./types";
 
+export async function getProvider(chain: EVMChain, customUrl?: string) {
+  const { JsonRpcProvider } = await import("ethers");
+
+  return new JsonRpcProvider(customUrl || SKConfig.get("rpcUrls")[chain]);
+}
+
+/**
+ * @deprecated
+ */
 export const estimateMaxSendableAmount = async ({
-  toolbox,
   from,
   memo = "",
   feeOptionKey = FeeOption.Fastest,
@@ -25,7 +35,11 @@ export const estimateMaxSendableAmount = async ({
   contractAddress,
   txOverrides,
 }: EVMMaxSendableAmountsParams): Promise<AssetValue> => {
-  const balance = (await toolbox.getBalance(from)).find(({ symbol, chain }) =>
+  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+  const toolbox = await getEvmToolbox(assetValue.chain as EVMChain);
+
+  const balances = await toolbox.getBalance(from);
+  const balance = balances.find(({ symbol, chain }) =>
     assetValue ? symbol === assetValue.symbol : symbol === AssetValue.from({ chain })?.symbol,
   );
 
@@ -47,24 +61,24 @@ export const estimateMaxSendableAmount = async ({
           txOverrides,
         })
       : await toolbox.estimateGasLimit({
-          from,
+          sender: from,
           recipient: from,
           memo,
           assetValue,
         });
 
   const isFeeEIP1559Compatible = "maxFeePerGas" in gasRate;
-  const isFeeEVMLegacyCompatible = "gasPrice" in gasRate;
+  const isFeeEVMLegacyCompatible = "gasPrice" in gasRate && gasRate.gasPrice !== undefined;
 
-  if (!(isFeeEVMLegacyCompatible || isFeeEIP1559Compatible)) {
+  if (!(gasRate && (isFeeEVMLegacyCompatible || isFeeEIP1559Compatible))) {
     throw new Error("Could not fetch fee data");
   }
 
-  const fee =
-    gasLimit *
-    (isFeeEIP1559Compatible
-      ? (gasRate.maxFeePerGas || 1n) + (gasRate.maxPriorityFeePerGas || 1n)
-      : gasRate.gasPrice);
+  const gasPrice = isFeeEIP1559Compatible
+    ? (gasRate.maxFeePerGas || 1n) + (gasRate.maxPriorityFeePerGas || 1n)
+    : gasRate.gasPrice || 1n;
+
+  const fee = gasLimit * gasPrice;
   const maxSendableAmount = SwapKitNumber.fromBigInt(balance.getBaseValue("bigint")).sub(
     fee.toString(),
   );
@@ -72,74 +86,88 @@ export const estimateMaxSendableAmount = async ({
   return AssetValue.from({ chain: balance.chain, value: maxSendableAmount.getValue("string") });
 };
 
-export const toHexString = (value: bigint) => (value > 0n ? `0x${value.toString(16)}` : "0x0");
+export function toHexString(value: bigint) {
+  return value > 0n ? `0x${value.toString(16)}` : "0x0";
+}
 
-export const getBalance = async ({
+export function getEstimateTransactionFee({
   provider,
-  address,
-  chain,
-  potentialScamFilter,
-}: {
-  provider: JsonRpcProvider | BrowserProvider;
-  address: string;
-  chain: EVMChain;
-  potentialScamFilter?: boolean;
-}) => {
-  const tokenBalances = await getEvmApi(chain).getBalance(address);
-  const evmGasTokenBalance = await provider.getBalance(address);
-
-  const balances = [
-    {
-      chain,
-      symbol: AssetValue.from({ chain }).symbol,
-      value: formatBigIntToSafeValue({
-        value: BigInt(evmGasTokenBalance),
-        decimal: 18,
-        bigIntDecimal: 18,
-      }),
-      decimal: BaseDecimal[chain],
-    },
-    ...tokenBalances.filter((token) => !isGasAsset(token)),
-  ];
-
-  const filteredBalances = potentialScamFilter ? filterAssets(balances) : balances;
-
-  return filteredBalances.map(
-    ({ symbol, value, decimal }) =>
-      new AssetValue({
-        decimal: decimal || BaseDecimal[chain],
-        value,
-        identifier: `${chain}.${symbol}`,
-      }),
-  );
-};
-
-export const estimateTransactionFee = async (
-  txObject: EIP1559TxParams,
-  // biome-ignore lint/style/useDefaultParameterLast: Should only be used through wrapped toolboxes
-  feeOption: FeeOption = FeeOption.Fast,
-  chain: EVMChain,
-  provider: Provider | BrowserProvider,
   isEIP1559Compatible = true,
-) => {
-  const gasPrices = (await estimateGasPrices(provider, isEIP1559Compatible))[feeOption];
-  const gasLimit = await provider.estimateGas(txObject);
-  const assetValue = AssetValue.from({ chain });
-
-  if (!isEIP1559Compatible && gasPrices.gasPrice) {
-    return assetValue.set(
-      SwapKitNumber.fromBigInt(gasPrices.gasPrice * gasLimit, assetValue.decimal),
-    );
-  }
-
-  if (gasPrices.maxFeePerGas && gasPrices.maxPriorityFeePerGas) {
-    return assetValue.set(
-      SwapKitNumber.fromBigInt(
-        (gasPrices.maxFeePerGas + gasPrices.maxPriorityFeePerGas) * gasLimit,
-        assetValue.decimal,
-      ),
-    );
+}: { provider: Provider | BrowserProvider; isEIP1559Compatible?: boolean; chain: EVMChain }) {
+  return async function estimateTransactionFee({
+    feeOption = FeeOption.Fast,
+    chain,
+    ...txObject
+  }: EIP1559TxParams & { feeOption: FeeOption; chain: EVMChain }) {
+    const estimateGasPrices = getEstimateGasPrices({ provider, isEIP1559Compatible, chain });
+    const gasPrices = await estimateGasPrices();
+    const gasLimit = await provider.estimateGas(txObject);
+
+    const assetValue = AssetValue.from({ chain });
+    const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = gasPrices[feeOption];
+
+    if (!isEIP1559Compatible && gasPrice) {
+      return assetValue.set(SwapKitNumber.fromBigInt(gasPrice * gasLimit, assetValue.decimal));
+    }
+
+    if (maxFeePerGas && maxPriorityFeePerGas) {
+      const fee = (maxFeePerGas + maxPriorityFeePerGas) * gasLimit;
+
+      return assetValue.set(SwapKitNumber.fromBigInt(fee, assetValue.decimal));
+    }
+
+    throw new Error("No gas price found");
+  };
+}
+
+export function getNetworkParams<C extends EVMChain>(chain: C) {
+  return () =>
+    (Chain.Ethereum === chain
+      ? undefined
+      : {
+          ...getNetworkInfo({ chain }),
+          chainId: ChainToHexChainId[chain],
+          rpcUrls: [SKConfig.get("rpcUrls")[chain]],
+          blockExplorerUrls: [ChainToExplorerUrl[chain]],
+        }) as C extends Chain.Ethereum ? undefined : NetworkParams;
+}
+
+export function getIsEIP1559Compatible<C extends EVMChain>(chain: C) {
+  const notCompatible = [Chain.Arbitrum, Chain.BinanceSmartChain];
+
+  return !notCompatible.includes(chain);
+}
+
+function getNetworkInfo<C extends EVMChain>({ chain }: { chain: C }) {
+  const decimals = BaseDecimal[chain];
+
+  switch (chain) {
+    case Chain.Arbitrum:
+      return {
+        chainName: "Arbitrum One",
+        nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals },
+      };
+    case Chain.Avalanche:
+      return {
+        chainName: "Avalanche Network",
+        nativeCurrency: { name: "Avalanche", symbol: chain, decimals },
+      };
+    case Chain.Base:
+      return {
+        chainName: "Base Mainnet",
+        nativeCurrency: { name: "Ethereum", symbol: Chain.Ethereum, decimals },
+      };
+    case Chain.BinanceSmartChain:
+      return {
+        chainName: "BNB Chain",
+        nativeCurrency: { name: "Binance Coin", symbol: "BNB", decimals },
+      };
+    case Chain.Polygon:
+      return {
+        chainName: "Polygon Mainnet",
+        nativeCurrency: { name: "Polygon", symbol: Chain.Polygon, decimals },
+      };
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
   }
-
-  throw new Error("No gas price found");
-};
+}

package/src/evm/index.ts

@@ -1,20 +1,4 @@
-/**
- * Package
- */
 export * from "./api";
 export * from "./helpers";
-export * from "./provider";
-export * from "./toolbox/EVMToolbox";
 export * from "./types";
-
-/**
- * Toolboxes
- */
-export * from "./toolbox/arb";
-export * from "./toolbox/avax";
-export * from "./toolbox/bsc";
-export * from "./toolbox/eth";
-export * from "./toolbox/getToolboxByChain";
-export * from "./toolbox/matic";
-export * from "./toolbox/op";
-export * from "./toolbox/base";
+export * from "./toolbox";