@swapkit/helpers 3.0.0-beta.0 → 3.0.0-beta.1

package/src/utils/asset.ts

@@ -1,12 +1,11 @@
+import { match } from "ts-pattern";
 import { AssetValue } from "../modules/assetValue";
 import { RequestClient } from "../modules/requestClient";
 import { SKConfig } from "../modules/swapKitConfig";
-import { BaseDecimal, Chain, type EVMChain, EVMChains } from "../types/chains";
+import { BaseDecimal, Chain, type EVMChain, EVMChains, UTXOChains } from "../types/chains";
 import type { RadixCoreStateResourceDTO } from "../types/radix";
 import type { TokenNames } from "../types/tokens";
 
-const getDecimalMethodHex = "0x313ce567";
-
 export type CommonAssetString = (typeof CommonAssetStrings)[number] | Chain;
 
 export type ConditionalAssetValueReturn<T extends boolean> = T extends true
@@ -22,7 +21,18 @@ export const CommonAssetStrings = [
   `${Chain.Radix}.XRD`,
 ] as const;
 
-const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
+const ethGasChains = [
+  Chain.Arbitrum,
+  Chain.Avalanche,
+  Chain.Base,
+  Chain.Ethereum,
+  Chain.Optimism,
+  Chain.Polygon,
+] as const;
+
+async function getContractDecimals({ chain, to }: { chain: EVMChain; to: string }) {
+  const getDecimalMethodHex = "0x313ce567";
+
   try {
     const { result } = await RequestClient.post<{ result: string }>(
       SKConfig.get("rpcUrls")[chain],
@@ -46,19 +56,18 @@ const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string
     console.error(error);
     return BaseDecimal[chain];
   }
-};
+}
+
+async function getRadixAssetDecimal(symbol: string) {
+  if (symbol === Chain.Radix) return BaseDecimal.XRD;
 
-const getRadixResourceDecimals = async ({ symbol }: { symbol: string }) => {
   try {
     const resourceAddress = symbol.split("-")[1]?.toLowerCase();
 
     const { manager } = await RequestClient.post<RadixCoreStateResourceDTO>(
       `${SKConfig.get("rpcUrls").XRD}/state/resource`,
       {
-        headers: {
-          Accept: "*/*",
-          "Content-Type": "application/json",
-        },
+        headers: { Accept: "*/*", "Content-Type": "application/json" },
         body: JSON.stringify({
           network: "mainnet",
           resource_address: resourceAddress,
@@ -71,173 +80,119 @@ const getRadixResourceDecimals = async ({ symbol }: { symbol: string }) => {
     console.error(error);
     return BaseDecimal[Chain.Radix];
   }
-};
+}
+
+async function getEVMAssetDecimal({ chain, symbol }: { chain: EVMChain; symbol: string }) {
+  if (EVMChains.includes(symbol as EVMChain)) return BaseDecimal[symbol as EVMChain];
 
-const getETHAssetDecimal = (symbol: string) => {
-  if (symbol === Chain.Ethereum) return BaseDecimal.ETH;
   const splitSymbol = symbol.split("-");
   const address =
     splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1]?.toLowerCase();
 
-  return address?.startsWith("0x")
-    ? getContractDecimals({ chain: Chain.Ethereum, to: address })
-    : BaseDecimal.ETH;
-};
-
-const getAVAXAssetDecimal = (symbol: string) => {
-  const splitSymbol = symbol.split("-");
-  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
-
-  return address?.startsWith("0x")
-    ? getContractDecimals({ chain: Chain.Avalanche, to: address.toLowerCase() })
-    : BaseDecimal.AVAX;
-};
-
-const getBSCAssetDecimal = (symbol: string) => {
-  if (symbol === Chain.BinanceSmartChain) return BaseDecimal.BSC;
-
-  return BaseDecimal.BSC;
-};
-
-const getRadixAssetDecimal = (symbol: string) => {
-  if (symbol === Chain.Radix) return BaseDecimal.XRD;
+  const decimal = await (address?.startsWith("0x")
+    ? getContractDecimals({ chain, to: address })
+    : BaseDecimal[chain as EVMChain]);
 
-  return getRadixResourceDecimals({ symbol });
-};
-
-export const getDecimal = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
-  switch (chain) {
-    case Chain.Ethereum:
-      return getETHAssetDecimal(symbol);
-    case Chain.Avalanche:
-      return getAVAXAssetDecimal(symbol);
-    case Chain.BinanceSmartChain:
-      return getBSCAssetDecimal(symbol);
-    case Chain.Radix:
-      return getRadixAssetDecimal(symbol);
-    default:
-      return BaseDecimal[chain];
-  }
-};
-
-export const getGasAsset = ({ chain }: { chain: Chain }) => {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Base:
-    case Chain.Optimism:
-      return AssetValue.from({ asset: `${chain}.ETH` });
-    case Chain.Maya:
-      return AssetValue.from({ asset: `${chain}.CACAO` });
-    case Chain.Cosmos:
-      return AssetValue.from({ asset: `${chain}.ATOM` });
-    case Chain.BinanceSmartChain:
-      return AssetValue.from({ asset: `${chain}.BNB` });
-    case Chain.THORChain:
-      return AssetValue.from({ asset: `${chain}.RUNE` });
+  return decimal;
+}
 
-    default:
-      return AssetValue.from({ asset: `${chain}.${chain}` });
-  }
-};
+export function getDecimal({ chain, symbol }: { chain: Chain; symbol: string }) {
+  return match(chain)
+    .with(...EVMChains, (chain) => getEVMAssetDecimal({ chain, symbol }))
+    .with(Chain.Radix, () => getRadixAssetDecimal(symbol))
+    .otherwise(() => BaseDecimal[chain]);
+}
 
-export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Base:
-    case Chain.Optimism:
-      return symbol === "ETH";
-    case Chain.Maya:
-      return symbol === "CACAO";
-    case Chain.Cosmos:
-      return symbol === "ATOM";
-    case Chain.BinanceSmartChain:
-      return symbol === "BNB";
-    case Chain.THORChain:
-      return symbol === "RUNE";
-    case Chain.Radix:
-      return `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier;
+/**
+ * @deprecated Use AssetValue.from({ chain }) instead
+ */
+export function getGasAsset({ chain }: { chain: Chain }) {
+  return AssetValue.from({ chain });
+}
 
-    default:
-      return symbol === chain;
-  }
-};
+export function isGasAsset({ chain, symbol }: { chain: Chain; symbol: string }) {
+  return match(chain)
+    .with(...ethGasChains, () => symbol === "ETH")
+    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
+    .with(Chain.Maya, () => symbol === "CACAO")
+    .with(Chain.Cosmos, () => symbol === "ATOM")
+    .with(Chain.THORChain, () => symbol === "RUNE")
+    .with(Chain.Radix, () => `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier)
+    .otherwise(() => symbol === chain);
+}
 
 export const getCommonAssetInfo = (assetString: CommonAssetString) => {
-  switch (assetString) {
-    case Chain.Arbitrum:
-    case Chain.Base:
-    case Chain.Optimism:
-      return { identifier: `${assetString}.ETH`, decimal: BaseDecimal[assetString] };
-
-    case `${Chain.Radix}.XRD`:
-    case Chain.Radix:
-      return {
-        identifier: "XRD.XRD-resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd",
-        decimal: BaseDecimal.XRD,
-      };
-
-    case `${Chain.Ethereum}.FLIP`:
-      return {
-        identifier: "ETH.FLIP-0x826180541412D574cf1336d22c0C0a287822678A",
-        decimal: BaseDecimal.ETH,
-      };
-    case `${Chain.Ethereum}.THOR`:
-      return {
-        identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
-        decimal: BaseDecimal.ETH,
-      };
-    case `${Chain.Ethereum}.vTHOR`:
-      return {
-        identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
-        decimal: BaseDecimal.ETH,
-      };
-
-    case Chain.Cosmos:
-      return { identifier: `${assetString}.ATOM`, decimal: BaseDecimal[assetString] };
-    case Chain.THORChain:
-      return { identifier: `${assetString}.RUNE`, decimal: BaseDecimal[assetString] };
-    case Chain.BinanceSmartChain:
-      return { identifier: `${assetString}.BNB`, decimal: BaseDecimal[assetString] };
-    case Chain.Maya:
-      return { identifier: `${assetString}.CACAO`, decimal: 10 };
-
-    case `${Chain.Maya}.MAYA`:
-      return { identifier: assetString, decimal: 4 };
-    case `${Chain.Kujira}.USK`:
-      return { identifier: assetString, decimal: 6 };
-
-    default:
-      return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
-  }
+  const decimal = BaseDecimal[assetString as Chain];
+
+  const commonAssetInfo = match(assetString.toUpperCase())
+    .with(...ethGasChains, () => ({
+      identifier: `${assetString.toUpperCase()}.ETH`,
+      decimal,
+    }))
+    .with(Chain.THORChain, () => ({
+      identifier: `${assetString.toUpperCase()}.RUNE`,
+      decimal,
+    }))
+    .with(Chain.Cosmos, () => ({ identifier: `${assetString.toUpperCase()}.ATOM`, decimal }))
+    .with(Chain.Maya, () => ({
+      identifier: `${assetString.toUpperCase()}.CACAO`,
+      decimal: 10,
+    }))
+    .with(Chain.BinanceSmartChain, () => ({
+      identifier: `${assetString.toUpperCase()}.BNB`,
+      decimal,
+    }))
+    .with(
+      ...UTXOChains,
+      Chain.Solana,
+      Chain.Chainflip,
+      Chain.Kujira,
+      Chain.Ripple,
+      Chain.Polkadot,
+      () => ({ identifier: `${assetString.toUpperCase()}.${assetString.toUpperCase()}`, decimal }),
+    )
+    .with(Chain.Radix, "XRD.XRD", () => ({
+      identifier: "XRD.XRD-resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd",
+      decimal,
+    }))
+    .with("KUJI.USK", () => ({ identifier: assetString.toUpperCase(), decimal: 6 }))
+    .with("ETH.FLIP", () => ({
+      identifier: "ETH.FLIP-0x826180541412D574cf1336d22c0C0a287822678A",
+      decimal: BaseDecimal.ETH,
+    }))
+    .with("ETH.THOR", () => ({
+      identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
+      decimal: BaseDecimal.ETH,
+    }))
+    .with("ETH.vTHOR", () => ({
+      identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
+      decimal: BaseDecimal.ETH,
+    }))
+    .with("MAYA.MAYA", () => ({ identifier: assetString.toUpperCase(), decimal: 4 }))
+    // Just to be sure that we are not missing any chain
+    .otherwise(() => ({ identifier: assetString, decimal }));
+
+  return commonAssetInfo;
 };
 
-export const getAssetType = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+export function getAssetType({ chain, symbol }: { chain: Chain; symbol: string }) {
   if (symbol.includes("/")) return "Synth";
-
-  switch (chain) {
-    case Chain.Radix:
-      return symbol === Chain.Radix || `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier
-        ? "Native"
-        : chain;
-
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Base:
-      return symbol === Chain.Ethereum ? "Native" : chain;
-
-    case Chain.Cosmos:
-      return symbol === "ATOM" ? "Native" : chain;
-    case Chain.BinanceSmartChain:
-      return symbol === "BNB" ? "Native" : chain;
-    case Chain.Maya:
-      return symbol === "CACAO" ? "Native" : chain;
-    case Chain.THORChain:
-      return symbol === "RUNE" ? "Native" : chain;
-
-    default:
-      return symbol === chain ? "Native" : chain;
-  }
-};
+  if (symbol.includes("~")) return "Trade";
+
+  const isNative = match(chain)
+    .with(
+      Chain.Radix,
+      () => symbol === Chain.Radix || `${chain}.${symbol}` === getCommonAssetInfo(chain).identifier,
+    )
+    .with(Chain.Arbitrum, Chain.Optimism, Chain.Base, () => symbol === Chain.Ethereum)
+    .with(Chain.Cosmos, () => symbol === "ATOM")
+    .with(Chain.BinanceSmartChain, () => symbol === "BNB")
+    .with(Chain.Maya, () => symbol === "CACAO")
+    .with(Chain.THORChain, () => symbol === "RUNE")
+    .otherwise(() => symbol === chain);
+
+  return isNative ? "Native" : chain;
+}
 
 export const assetFromString = (assetString: string) => {
   const [chain, ...symbolArray] = assetString.split(".") as [Chain, ...(string | undefined)[]];
@@ -253,36 +208,6 @@ export const assetFromString = (assetString: string) => {
   return { chain, symbol, ticker, synth };
 };
 
-const potentialScamRegex = new RegExp(
-  /(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/,
-  "gmi",
-);
-
-const evmAssetHasAddress = (assetString: string) => {
-  const [chain, symbol] = assetString.split(".") as [EVMChain, string];
-  if (!EVMChains.includes(chain as EVMChain)) return true;
-  const splitSymbol = symbol.split("-");
-  const address = splitSymbol.length === 1 ? undefined : splitSymbol[splitSymbol.length - 1];
-
-  return isGasAsset({ chain: chain as Chain, symbol }) || !!address;
-};
-
-export const filterAssets = (
-  tokens: {
-    value: string;
-    decimal: number;
-    chain: Chain;
-    symbol: string;
-  }[],
-) =>
-  tokens.filter(({ chain, value, symbol }) => {
-    const assetString = `${chain}.${symbol}`;
-
-    return (
-      !potentialScamRegex.test(assetString) && evmAssetHasAddress(assetString) && value !== "0"
-    );
-  });
-
 export async function findAssetBy(
   params:
     | { chain: EVMChain | Chain.Radix | Chain.Solana; contract: string }
@@ -308,27 +233,3 @@ export async function findAssetBy(
 
   return;
 }
-
-export const blockTimes = {
-  [Chain.Arbitrum]: 1,
-  [Chain.Avalanche]: 3,
-  [Chain.Base]: 1,
-  [Chain.BinanceSmartChain]: 3,
-  [Chain.Bitcoin]: 600,
-  [Chain.BitcoinCash]: 600,
-  [Chain.Chainflip]: 5,
-  [Chain.Cosmos]: 1.5,
-  [Chain.Dash]: 150,
-  [Chain.Dogecoin]: 600,
-  [Chain.Ethereum]: 12.5,
-  [Chain.Fiat]: 60,
-  [Chain.Kujira]: 2.2,
-  [Chain.Litecoin]: 150,
-  [Chain.Maya]: 6,
-  [Chain.Optimism]: 1,
-  [Chain.Polkadot]: 6,
-  [Chain.Polygon]: 2.1,
-  [Chain.Radix]: 5,
-  [Chain.Solana]: 1,
-  [Chain.THORChain]: 6,
-};

package/src/utils/derivationPath.ts

@@ -13,10 +13,27 @@ type Params = {
   type?: "legacy" | "ledgerLive" | "nativeSegwitMiddleAccount" | "segwit" | "account";
 };
 
-export const updatedLastIndex = (path: DerivationPathArray, index: number) => {
-  const newPath = [...path.slice(0, path.length - 1), index];
-  return newPath as DerivationPathArray;
-};
+export function updateDerivationPath(
+  path: DerivationPathArray,
+  params: { index: number } | { account: number } | { change: number },
+) {
+  if ("index" in params) {
+    const newPath = [...path.slice(0, path.length - 1), params.index];
+    return newPath as DerivationPathArray;
+  }
+
+  if ("change" in params) {
+    const [network, chainId, account, , index] = path;
+    return [network, chainId, account, params.change, index] as DerivationPathArray;
+  }
+
+  if ("account" in params) {
+    const [network, chainId, , change, index] = path;
+    return [network, chainId, params.account, change, index] as DerivationPathArray;
+  }
+
+  return path;
+}
 
 export function derivationPathToString([network, chainId, account, change, index]:
   | [number, number, number, number, number?]
@@ -37,12 +54,12 @@ export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: P
       return [44, 60, index, 0, addressIndex] as DerivationPathArray;
     }
 
-    return updatedLastIndex(NetworkDerivationPath[chain], index);
+    return updateDerivationPath(NetworkDerivationPath[chain], { index });
   }
 
   if (chain === Chain.Solana) {
     if (type === "account") return [44, 501, 0, index] as DerivationPathArray;
-    return updatedLastIndex(NetworkDerivationPath[chain], index);
+    return updateDerivationPath(NetworkDerivationPath[chain], { index });
   }
 
   const chainId = chain === Chain.Litecoin ? 2 : 0;
@@ -55,7 +72,7 @@ export function getDerivationPathFor({ chain, index, addressIndex = 0, type }: P
     case "legacy":
       return [44, chainId, 0, 0, index] as DerivationPathArray;
     default:
-      return updatedLastIndex(NetworkDerivationPath[chain], index);
+      return updateDerivationPath(NetworkDerivationPath[chain], { index });
   }
 }
 

package/src/utils/plugin.ts

@@ -3,7 +3,7 @@ import type { ProviderName, SwapKitPluginParams } from "../types";
 export function createPlugin<
   const Name extends string,
   T extends (params: SwapKitPluginParams) => Record<string, unknown>,
-  K extends { supportedSwapkitProviders?: ProviderName[] },
+  K extends { supportedSwapkitProviders?: (ProviderName | string)[] },
 >({ name, properties, methods }: { name: Name; properties?: K; methods: T }) {
   function plugin(pluginParams: SwapKitPluginParams) {
     return { ...methods(pluginParams), ...properties } as K & ReturnType<T>;

package/src/utils/tokens.ts

@@ -0,0 +1,73 @@
+import { match } from "ts-pattern";
+import type * as tokenLists from "../tokens/lists";
+
+export type TokenLists = {
+  camelot: typeof tokenLists.CamelotV3List;
+  caviar: typeof tokenLists.CaviarV1List;
+  chainflip: typeof tokenLists.ChainflipList;
+  jupiter: typeof tokenLists.JupiterList;
+  mayachain: typeof tokenLists.MayaList;
+  oneinch: typeof tokenLists.OneInchList;
+  openocean: typeof tokenLists.OpenOceanV2List;
+  pancakeswap: typeof tokenLists.PancakeswapList;
+  pangolin: typeof tokenLists.PangolinList;
+  sushiswap: typeof tokenLists.SushiswapList;
+  thorchain: typeof tokenLists.ThorchainList;
+  traderjoe: typeof tokenLists.TraderjoeV2List;
+  uniswap: typeof tokenLists.UniswapV2List;
+  uniswapv3: typeof tokenLists.UniswapV3List;
+};
+
+export type TokenListName = keyof TokenLists;
+
+const defaultLists = [
+  "camelot",
+  "caviar",
+  "chainflip",
+  "jupiter",
+  "mayachain",
+  "oneinch",
+  "openocean",
+  "pancakeswap",
+  "pangolin",
+  "sushiswap",
+  "thorchain",
+  "traderjoe",
+  "uniswap",
+  "uniswapv3",
+] as TokenListName[];
+
+export async function loadTokenLists<T extends TokenListName[]>(pickedLists?: T) {
+  const listsToLoad = pickedLists || defaultLists;
+  const lists = {} as { [key in T[number]]: TokenLists[key] };
+
+  for (const list of listsToLoad) {
+    const tokenList = await loadTokenList(list);
+
+    // @ts-expect-error - It's fine to do this because we know the type of the list
+    lists[list] = tokenList;
+  }
+
+  return lists;
+}
+
+async function loadTokenList<T extends TokenListName>(listName: T): Promise<TokenLists[T]> {
+  const { list } = await match(listName as TokenListName)
+    .with("camelot", () => import("../tokens/lists/camelot_v3"))
+    .with("caviar", () => import("../tokens/lists/caviar_v1"))
+    .with("chainflip", () => import("../tokens/lists/chainflip"))
+    .with("jupiter", () => import("../tokens/lists/jupiter"))
+    .with("mayachain", () => import("../tokens/lists/mayachain"))
+    .with("oneinch", () => import("../tokens/lists/oneinch"))
+    .with("openocean", () => import("../tokens/lists/openocean_v2"))
+    .with("pancakeswap", () => import("../tokens/lists/pancakeswap"))
+    .with("pangolin", () => import("../tokens/lists/pangolin_v1"))
+    .with("sushiswap", () => import("../tokens/lists/sushiswap_v2"))
+    .with("thorchain", () => import("../tokens/lists/thorchain"))
+    .with("traderjoe", () => import("../tokens/lists/traderjoe_v2"))
+    .with("uniswap", () => import("../tokens/lists/uniswap_v2"))
+    .with("uniswapv3", () => import("../tokens/lists/uniswap_v3"))
+    .exhaustive();
+
+  return list as unknown as TokenLists[T];
+}

package/src/utils/validators.ts

@@ -1,8 +1,9 @@
+import { SKConfig } from "../modules/swapKitConfig";
 import { SwapKitError } from "../modules/swapKitError";
-import { Chain } from "../types/chains";
+import type { Chain } from "../types/chains";
 
 // Backward compatibility
-const supportedChains = [...Object.values(Chain), "TERRA"];
+const supportedChains = ["TERRA", ...SKConfig.get("chains")];
 
 export function validateIdentifier(identifier = "") {
   const uppercasedIdentifier = identifier.toUpperCase();

package/src/utils/wallets.ts

@@ -1,4 +1,5 @@
-import type { BrowserProvider } from "ethers";
+import type { getEvmToolbox } from "@swapkit/toolboxes/evm";
+import type { BrowserProvider, JsonRpcProvider } from "ethers";
 import { SwapKitError } from "../modules/swapKitError";
 import {
   type AddChainType,
@@ -19,6 +20,7 @@ declare const window: {
   braveSolana: any;
   bitkeep?: { ethereum: EthereumWindowProvider };
   xfi?: { ethereum: EthereumWindowProvider };
+  $onekey?: { ethereum: EthereumWindowProvider };
 } & Window;
 
 export function isWeb3Detected() {
@@ -40,6 +42,7 @@ export function listWeb3EVMWallets() {
       window?.ethereum?.selectedProvider?.isCoinbaseWallet) ||
     window?.coinbaseWalletExtension;
   const bitgetEnabled = window?.bitkeep?.ethereum;
+  const onekeyEnabled = window?.$onekey?.ethereum;
 
   const wallets = [];
   if (metamaskEnabled) wallets.push(WalletOption.METAMASK);
@@ -49,6 +52,7 @@ export function listWeb3EVMWallets() {
   if (coinbaseEnabled) wallets.push(WalletOption.COINBASE_WEB);
   if (okxMobileEnabled()) wallets.push(WalletOption.OKX_MOBILE);
   if (bitgetEnabled) wallets.push(WalletOption.BITGET);
+  if (onekeyEnabled) wallets.push(WalletOption.ONEKEY);
 
   return wallets;
 }
@@ -116,12 +120,15 @@ export function wrapMethodWithNetworkSwitch<T extends (...args: any[]) => any>(
   }) as unknown as T;
 }
 
-export function prepareNetworkSwitch<T extends { [key: string]: (...args: any[]) => any }>({
+export function prepareNetworkSwitch<
+  T extends Awaited<ReturnType<typeof getEvmToolbox>>,
+  M extends keyof T,
+>({
   toolbox,
   chain,
   provider = window.ethereum,
   methodNames = [],
-}: { toolbox: T; chain: Chain; provider?: BrowserProvider; methodNames?: string[] }) {
+}: { toolbox: T; chain: Chain; provider?: BrowserProvider | JsonRpcProvider; methodNames?: M[] }) {
   const methodsToWrap = [
     ...methodNames,
     "approve",
@@ -138,18 +145,19 @@ export function prepareNetworkSwitch<T extends { [key: string]: (...args: any[])
     "estimateGasLimit",
     "estimateGasPrices",
     "createContractTxObject",
-  ];
+  ] as M[];
   const wrappedMethods = methodsToWrap.reduce((object, methodName) => {
     if (!toolbox[methodName]) return object;
+
     const method = toolbox[methodName];
 
     if (typeof method !== "function") return object;
 
-    return {
-      // biome-ignore lint/performance/noAccumulatingSpread: This is a valid use case
-      ...object,
-      [methodName]: wrapMethodWithNetworkSwitch<typeof method>(method, provider, chain),
-    };
+    // @ts-expect-error
+    const wrappedMethod = wrapMethodWithNetworkSwitch(method, provider, chain);
+
+    // biome-ignore lint/performance/noAccumulatingSpread: valid use case
+    return { ...object, [methodName]: wrappedMethod };
   }, {});
 
   return { ...toolbox, ...wrappedMethods };
@@ -171,6 +179,7 @@ export function getETHDefaultWallet() {
   if (isBraveWallet) return WalletOption.BRAVE;
   if (overrideIsMetaMask && selectedProvider?.isCoinbaseWallet) return WalletOption.COINBASE_WEB;
   if (__XDEFI) WalletOption.CTRL;
+  if (window?.$onekey?.ethereum) return WalletOption.ONEKEY;
   return WalletOption.METAMASK;
 }
 
@@ -220,7 +229,7 @@ export function createWallet<
   }) => (...params: ConnectParams) => Promise<boolean>;
   name: Name;
   supportedChains: SupportedChains;
-  walletType?: WalletType;
+  walletType?: WalletType | string;
 }) {
   function connectWallet(connectParams: {
     addChain: AddChainType;