@swapkit/helpers 2.6.0 → 3.0.0-beta.1

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/{helpers → utils}/validators.ts

@@ -1,17 +1,19 @@
+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();
 
-  const supportedThorchainSeperatorRegex = /\.|~|\//;
-  const [chain] = uppercasedIdentifier.split(supportedThorchainSeperatorRegex) as [Chain, string];
-
+  const [chain] = uppercasedIdentifier.split(".") as [Chain, string];
   if (supportedChains.includes(chain)) return true;
 
+  const [synthChain] = uppercasedIdentifier.split("/") as [Chain, string];
+  if (supportedChains.includes(synthChain)) return true;
+
   throw new SwapKitError({
     errorKey: "helpers_invalid_identifier",
     info: {

package/src/{helpers/web3wallets.ts → utils/wallets.ts}

@@ -1,27 +1,17 @@
-import type { BrowserProvider } from "ethers";
+import type { getEvmToolbox } from "@swapkit/toolboxes/evm";
+import type { BrowserProvider, JsonRpcProvider } from "ethers";
 import { SwapKitError } from "../modules/swapKitError";
 import {
-  Chain,
-  ChainId,
+  type AddChainType,
+  type Chain,
+  ChainToHexChainId,
   type EIP6963AnnounceProviderEvent,
   type EIP6963Provider,
+  type EthereumWindowProvider,
+  type NetworkParams,
   WalletOption,
 } from "../types";
-
-export type EthereumWindowProvider = BrowserProvider & {
-  __XDEFI?: boolean;
-  isBraveWallet?: boolean;
-  isCoinbaseWallet?: boolean;
-  isMetaMask?: boolean;
-  isOkxWallet?: boolean;
-  isKeepKeyWallet?: boolean;
-  isTrust?: boolean;
-  isTalisman?: boolean;
-  on: (event: string, callback?: () => void) => void;
-  overrideIsMetaMask?: boolean;
-  request: <T = unknown>(args: { method: string; params?: unknown[] }) => Promise<T>;
-  selectedProvider?: EthereumWindowProvider;
-};
+import { warnOnce } from "./others";
 
 declare const window: {
   ethereum: EthereumWindowProvider;
@@ -30,57 +20,96 @@ declare const window: {
   braveSolana: any;
   bitkeep?: { ethereum: EthereumWindowProvider };
   xfi?: { ethereum: EthereumWindowProvider };
+  $onekey?: { ethereum: EthereumWindowProvider };
 } & Window;
 
-type NetworkParams = {
-  chainId: ChainId;
-  chainName: string;
-  nativeCurrency: {
-    name: string;
-    symbol: string;
-    decimals: number;
-  };
-  rpcUrls: string[];
-  blockExplorerUrls: string[];
-};
+export function isWeb3Detected() {
+  return typeof window.ethereum !== "undefined";
+}
 
-type ProviderRequestParams = {
-  provider?: BrowserProvider;
-  params?: any;
-  method:
-    | "wallet_addEthereumChain"
-    | "wallet_switchEthereumChain"
-    | "eth_requestAccounts"
-    | "eth_sendTransaction"
-    | "eth_sendRawTransaction"
-    | "eth_signTransaction";
-};
-
-const methodsToWrap = [
-  "approve",
-  "approvedAmount",
-  "call",
-  "sendTransaction",
-  "transfer",
-  "isApproved",
-  "approvedAmount",
-  "EIP1193SendTransaction",
-  "getFeeData",
-  "broadcastTransaction",
-  "estimateCall",
-  "estimateGasLimit",
-  "estimateGasPrices",
-  "createContractTxObject",
-];
-
-export const wrapMethodWithNetworkSwitch = <T extends (...args: any[]) => any>(
+export function isDetected(walletOption: WalletOption) {
+  return listWeb3EVMWallets().includes(walletOption);
+}
+
+export function listWeb3EVMWallets() {
+  const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
+  // @ts-ignore that should be implemented in ctrl and hooked up via swapkit core
+  const ctrlEnabled = window?.xfi || window?.ethereum?.__XDEFI;
+  const braveEnabled = window?.ethereum?.isBraveWallet;
+  const trustEnabled = window?.ethereum?.isTrust || window?.trustwallet;
+  const coinbaseEnabled =
+    (window?.ethereum?.overrideIsMetaMask &&
+      window?.ethereum?.selectedProvider?.isCoinbaseWallet) ||
+    window?.coinbaseWalletExtension;
+  const bitgetEnabled = window?.bitkeep?.ethereum;
+  const onekeyEnabled = window?.$onekey?.ethereum;
+
+  const wallets = [];
+  if (metamaskEnabled) wallets.push(WalletOption.METAMASK);
+  if (ctrlEnabled) wallets.push(WalletOption.CTRL);
+  if (braveEnabled) wallets.push(WalletOption.BRAVE);
+  if (trustEnabled) wallets.push(WalletOption.TRUSTWALLET_WEB);
+  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;
+}
+
+export async function switchEVMWalletNetwork(
+  provider: BrowserProvider,
+  chain: Chain,
+  networkParams?: NetworkParams,
+) {
+  try {
+    await providerRequest({
+      provider,
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: ChainToHexChainId[chain] }],
+    });
+  } catch (_error) {
+    if (!networkParams) {
+      throw new Error("Failed to switch network, networkParams not provided");
+    }
+    await addEVMWalletNetwork(provider, networkParams);
+  }
+}
+
+export function filterSupportedChains<T extends string[]>({
+  chains,
+  supportedChains,
+  walletType,
+}: { chains: Chain[]; supportedChains: T; walletType?: WalletOption }) {
+  const supported = chains.filter((chain) => supportedChains.includes(chain));
+
+  if (supported.length === 0) {
+    throw new SwapKitError("wallet_chain_not_supported", {
+      wallet: walletType,
+      chain: chains.join(", "),
+    });
+  }
+
+  const unsupported = chains.filter((chain) => !supportedChains.includes(chain));
+
+  warnOnce(
+    unsupported.length > 0,
+    `${walletType} wallet does not support the following chains: ${unsupported.join(
+      ", ",
+    )}. These chains will be ignored.`,
+  );
+
+  return supported as T;
+}
+
+export function wrapMethodWithNetworkSwitch<T extends (...args: any[]) => any>(
   func: T,
   provider: BrowserProvider,
-  chainId: ChainId,
-) =>
+  chain: Chain,
+) {
   (async (...args: any[]) => {
     try {
-      await switchEVMWalletNetwork(provider, chainId);
+      await switchEVMWalletNetwork(provider, chain);
     } catch (error) {
       throw new SwapKitError({
         errorKey: "helpers_failed_to_switch_network",
@@ -89,110 +118,69 @@ export const wrapMethodWithNetworkSwitch = <T extends (...args: any[]) => any>(
     }
     return func(...args);
   }) as unknown as T;
+}
 
-const providerRequest = ({ provider, params, method }: ProviderRequestParams) => {
-  if (!provider?.send) {
-    throw new SwapKitError("helpers_not_found_provider");
-  }
-
-  const providerParams = params ? (Array.isArray(params) ? params : [params]) : [];
-  return provider.send(method, providerParams);
-};
-
-export const prepareNetworkSwitch = <T extends { [key: string]: (...args: any[]) => any }>({
+export function prepareNetworkSwitch<
+  T extends Awaited<ReturnType<typeof getEvmToolbox>>,
+  M extends keyof T,
+>({
   toolbox,
-  chainId,
+  chain,
   provider = window.ethereum,
-}: {
-  toolbox: T;
-  chainId: ChainId;
-  provider?: BrowserProvider;
-}) => {
+  methodNames = [],
+}: { toolbox: T; chain: Chain; provider?: BrowserProvider | JsonRpcProvider; methodNames?: M[] }) {
+  const methodsToWrap = [
+    ...methodNames,
+    "approve",
+    "approvedAmount",
+    "call",
+    "sendTransaction",
+    "transfer",
+    "isApproved",
+    "approvedAmount",
+    "EIP1193SendTransaction",
+    "getFeeData",
+    "broadcastTransaction",
+    "estimateCall",
+    "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, chainId),
-    };
+    // @ts-expect-error
+    const wrappedMethod = wrapMethodWithNetworkSwitch(method, provider, chain);
+
+    // biome-ignore lint/performance/noAccumulatingSpread: valid use case
+    return { ...object, [methodName]: wrappedMethod };
   }, {});
 
   return { ...toolbox, ...wrappedMethods };
-};
-
-export const addEVMWalletNetwork = (provider: BrowserProvider, networkParams: NetworkParams) =>
-  providerRequest({ provider, method: "wallet_addEthereumChain", params: [networkParams] });
+}
 
-export const switchEVMWalletNetwork = (
-  provider: BrowserProvider,
-  chainId = ChainId.EthereumHex,
-  networkParams?: NetworkParams,
-) => {
-  try {
-    providerRequest({ provider, method: "wallet_switchEthereumChain", params: [{ chainId }] });
-  } catch (_error) {
-    if (!networkParams) {
-      throw new Error("Failed to switch network, networkParams not provided");
-    }
-    addEVMWalletNetwork(provider, networkParams);
-  }
-};
+export function addEVMWalletNetwork(provider: BrowserProvider, networkParams: NetworkParams) {
+  return providerRequest({ provider, method: "wallet_addEthereumChain", params: [networkParams] });
+}
 
-export const addAccountsChangedCallback = (callback: () => void) => {
+export function addAccountsChangedCallback(callback: () => void) {
   window.ethereum?.on("accountsChanged", () => callback());
   window.xfi?.ethereum.on("accountsChanged", () => callback());
-};
+}
 
-export const getETHDefaultWallet = () => {
+export function getETHDefaultWallet() {
   const { isTrust, isBraveWallet, __XDEFI, overrideIsMetaMask, selectedProvider } =
     window?.ethereum || {};
   if (isTrust) return WalletOption.TRUSTWALLET_WEB;
   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;
-};
-
-export const isDetected = (walletOption: WalletOption) => {
-  return listWeb3EVMWallets().includes(walletOption);
-};
-
-export const listWeb3EVMWallets = () => {
-  const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
-  // @ts-ignore that should be implemented in ctrl and hooked up via swapkit core
-  const ctrlEnabled = window?.xfi || window?.ethereum?.__XDEFI;
-  const braveEnabled = window?.ethereum?.isBraveWallet;
-  const trustEnabled = window?.ethereum?.isTrust || window?.trustwallet;
-  const coinbaseEnabled =
-    (window?.ethereum?.overrideIsMetaMask &&
-      window?.ethereum?.selectedProvider?.isCoinbaseWallet) ||
-    window?.coinbaseWalletExtension;
-  const bitgetEnabled = window?.bitkeep?.ethereum;
-
-  const wallets = [];
-  if (metamaskEnabled) wallets.push(WalletOption.METAMASK);
-  if (ctrlEnabled) wallets.push(WalletOption.CTRL);
-  if (braveEnabled) wallets.push(WalletOption.BRAVE);
-  if (trustEnabled) wallets.push(WalletOption.TRUSTWALLET_WEB);
-  if (coinbaseEnabled) wallets.push(WalletOption.COINBASE_WEB);
-  if (okxMobileEnabled()) wallets.push(WalletOption.OKX_MOBILE);
-  if (bitgetEnabled) wallets.push(WalletOption.BITGET);
-
-  return wallets;
-};
-
-export function pickEvmApiKey({
-  chain,
-  nonEthApiKey,
-  ethApiKey,
-}: { chain: Chain; nonEthApiKey?: string; ethApiKey?: string }) {
-  const apiKey = chain === Chain.Ethereum ? ethApiKey : nonEthApiKey;
-
-  return apiKey;
 }
 
 export function getEIP6963Wallets() {
@@ -213,7 +201,7 @@ export function getEIP6963Wallets() {
   return { providers, removeEIP6963EventListener };
 }
 
-export const okxMobileEnabled = () => {
+export function okxMobileEnabled() {
   const ua = navigator.userAgent;
   const isIOS = /iphone|ipad|ipod|ios/i.test(ua);
   const isAndroid = /android|XiaoMi|MiuiBrowser/i.test(ua);
@@ -221,6 +209,62 @@ export const okxMobileEnabled = () => {
   const isOKApp = /OKApp/i.test(ua);
 
   return isMobile && isOKApp;
-};
+}
+
+export function createWallet<
+  ConnectParams extends any[],
+  SupportedChains extends Chain[],
+  const Name extends string,
+  WalletType extends WalletOption,
+>({
+  connect,
+  name,
+  supportedChains,
+  walletType,
+}: {
+  connect: (connectParams: {
+    addChain: AddChainType;
+    walletType: WalletType;
+    supportedChains: SupportedChains;
+  }) => (...params: ConnectParams) => Promise<boolean>;
+  name: Name;
+  supportedChains: SupportedChains;
+  walletType?: WalletType | string;
+}) {
+  function connectWallet(connectParams: {
+    addChain: AddChainType;
+  }) {
+    return connect({ ...connectParams, walletType: walletType as WalletType, supportedChains });
+  }
+
+  return {
+    [name]: { supportedChains, connectWallet },
+  } as unknown as {
+    [key in Name]: {
+      connectWallet: typeof connectWallet;
+      supportedChains: SupportedChains;
+    };
+  };
+}
 
-export const isWeb3Detected = () => typeof window.ethereum !== "undefined";
+function providerRequest({
+  provider,
+  params,
+  method,
+}: {
+  provider?: BrowserProvider;
+  params?: any;
+  method:
+    | "wallet_addEthereumChain"
+    | "wallet_switchEthereumChain"
+    | "eth_requestAccounts"
+    | "eth_sendTransaction"
+    | "eth_signTransaction";
+}) {
+  if (!provider?.send) {
+    throw new SwapKitError("helpers_not_found_provider");
+  }
+
+  const providerParams = params ? (Array.isArray(params) ? params : [params]) : [];
+  return provider.send(method, providerParams);
+}