@swapkit/core 1.0.0-rc.120 → 1.0.0-rc.122

package/src/client/old.ts

@@ -1,854 +0,0 @@
-import type { ErrorKeys, QuoteRoute, ThornameRegisterParam } from "@swapkit/helpers";
-import {
-  AssetValue,
-  SwapKitApi,
-  SwapKitError,
-  SwapKitNumber,
-  gasFeeMultiplier,
-  getMemoFor,
-  getMinAmountByChain,
-  wrapWithThrow,
-} from "@swapkit/helpers";
-import type { CosmosLikeToolbox } from "@swapkit/toolbox-cosmos";
-import type { AVAXToolbox, BSCToolbox, ETHToolbox, EVMToolbox } from "@swapkit/toolbox-evm";
-import type { UTXOToolbox } from "@swapkit/toolbox-utxo";
-import type {
-  AddChainWalletParams,
-  EVMChain,
-  EVMWalletOptions,
-  ExtendParams,
-  WalletOption,
-} from "@swapkit/types";
-import {
-  AGG_SWAP,
-  Chain,
-  ChainToChainId,
-  FeeOption,
-  MemoType,
-  SWAP_IN,
-  SWAP_OUT,
-  TCAvalancheDepositABI,
-  TCBscDepositABI,
-  TCEthereumVaultAbi,
-} from "@swapkit/types";
-
-import type { AGG_CONTRACT_ADDRESS } from "../aggregator/contracts/index.ts";
-import { lowercasedContractAbiMapping } from "../aggregator/contracts/index.ts";
-import { getSwapInParams } from "../aggregator/getSwapParams.ts";
-
-import { getExplorerAddressUrl, getExplorerTxUrl } from "../helpers/explorerUrls.ts";
-import type {
-  CoreTxParams,
-  EVMWallet,
-  OldWallet,
-  SwapWithRouteParams,
-  ThorchainWallet,
-  WalletMethods,
-} from "../types.ts";
-
-const getEmptyWalletStructure = () =>
-  (Object.values(Chain) as Chain[]).reduce(
-    (acc, chain) => {
-      acc[chain] = null;
-      return acc;
-    },
-    {} as Record<Chain, null>,
-  );
-
-const validateAddressType = ({
-  chain,
-  address,
-}: {
-  chain: Chain;
-  address?: string;
-}) => {
-  if (!address) return false;
-
-  switch (chain) {
-    case Chain.Bitcoin:
-      // filter out taproot addresses
-      return !address.startsWith("bc1p");
-    default:
-      return true;
-  }
-};
-
-/**
- * @deprecated Use SwapKit instead (import { SwapKit } from "@swapkit/core")
- */
-export class SwapKitCore<T = ""> {
-  public connectedChains: OldWallet = getEmptyWalletStructure();
-  public connectedWallets: WalletMethods = getEmptyWalletStructure();
-  public readonly stagenet: boolean = false;
-
-  constructor({ stagenet }: { stagenet?: boolean } | undefined = {}) {
-    this.stagenet = !!stagenet;
-  }
-
-  getAddress = (chain: Chain) => this.connectedChains[chain]?.address || "";
-  getExplorerTxUrl = (chain: Chain, txHash: string) => getExplorerTxUrl({ chain, txHash });
-  getWallet = <T extends Chain>(chain: Chain) => this.connectedWallets[chain] as WalletMethods[T];
-  getExplorerAddressUrl = (chain: Chain, address: string) =>
-    getExplorerAddressUrl({ chain, address });
-  getBalance = async (chain: Chain, potentialScamFilter?: boolean) => {
-    const wallet = await this.getWalletByChain(chain, potentialScamFilter);
-
-    return wallet?.balance || [];
-  };
-
-  swap = async ({
-    streamSwap,
-    recipient,
-    route,
-    feeOptionKey = FeeOption.Average,
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-  }: SwapWithRouteParams) => {
-    const {
-      meta: { quoteMode },
-      //   evmTransactionDetails: contractCallParams,
-    } = route as QuoteRoute;
-    const evmChain = quoteMode.startsWith("ERC20-")
-      ? Chain.Ethereum
-      : quoteMode.startsWith("ARC20-")
-        ? Chain.Avalanche
-        : quoteMode.startsWith("BEP20-")
-          ? Chain.BinanceSmartChain
-          : undefined;
-
-    if (!(route as QuoteRoute).complete) throw new SwapKitError("core_swap_route_not_complete");
-
-    // TODO enable when BE is ready
-    //   if (contractCallParams && evmChain) {
-    //     const walletMethods = this.connectedWallets[evmChain];
-
-    //     if (!walletMethods?.call) {
-    //       throw new SwapKitError('core_wallet_connection_not_found');
-    //     }
-
-    //     const { contractAddress, contractMethod, contractParams, contractParamsStreaming } =
-    //       contractCallParams;
-
-    //     if (!(streamSwap ? contractParamsStreaming : contractParams)) {
-    //       throw new SwapKitError('core_swap_route_transaction_not_found');
-    //     }
-
-    //     return await walletMethods.call<string>({
-    //       contractAddress,
-    //       abi: lowercasedContractAbiMapping[contractAddress.toLowerCase()],
-    //       funcName: contractMethod,
-    //       funcParams: streamSwap ? contractParamsStreaming : contractParams,
-    //     });
-    //   }
-
-    if (AGG_SWAP.includes(quoteMode) && evmChain) {
-      const walletMethods = this.connectedWallets[evmChain];
-      if (!walletMethods?.sendTransaction) {
-        throw new SwapKitError("core_wallet_connection_not_found");
-      }
-
-      const transaction = streamSwap
-        ? (route as QuoteRoute)?.streamingSwap?.transaction
-        : (route as QuoteRoute)?.transaction;
-      if (!transaction) throw new SwapKitError("core_swap_route_transaction_not_found");
-
-      const { data, from, to, value } = (route as QuoteRoute).transaction;
-
-      const params = {
-        data,
-        from,
-        to: to.toLowerCase(),
-        chainId: BigInt(ChainToChainId[evmChain]),
-        value: value ? BigInt(value) : 0n,
-      };
-
-      return walletMethods.sendTransaction(params, feeOptionKey) as Promise<string>;
-    }
-
-    if (SWAP_OUT.includes(quoteMode)) {
-      if (!(route as QuoteRoute).calldata.fromAsset)
-        throw new SwapKitError("core_swap_asset_not_recognized");
-      // @ts-expect-error
-      const asset = await AssetValue.fromString((route as QuoteRoute).calldata.fromAsset);
-      if (!asset) throw new SwapKitError("core_swap_asset_not_recognized");
-
-      const { address: recipient } = await this.#getInboundDataByChain(asset.chain);
-      const {
-        contract: router,
-        calldata: { expiration, amountIn, memo, memoStreamingSwap },
-      } = route as QuoteRoute;
-
-      const assetValue = asset.add(SwapKitNumber.fromBigInt(BigInt(amountIn), asset.decimal));
-      const swapMemo = (streamSwap ? memoStreamingSwap || memo : memo) as string;
-
-      return this.deposit({
-        expiration,
-        assetValue,
-        memo: swapMemo,
-        feeOptionKey,
-        router,
-        recipient,
-      });
-    }
-
-    if (SWAP_IN.includes(quoteMode) && evmChain) {
-      const { calldata, contract: contractAddress } = route as QuoteRoute;
-      if (!contractAddress) throw new SwapKitError("core_swap_contract_not_found");
-
-      const walletMethods = this.connectedWallets[evmChain];
-      const from = this.getAddress(evmChain);
-
-      if (!(walletMethods?.sendTransaction && from)) {
-        throw new SwapKitError("core_wallet_connection_not_found");
-      }
-
-      const { getProvider, toChecksumAddress } = await import("@swapkit/toolbox-evm");
-      const provider = getProvider(evmChain);
-      const abi = lowercasedContractAbiMapping[contractAddress.toLowerCase()];
-
-      if (!abi)
-        throw new SwapKitError("core_swap_contract_not_supported", {
-          contractAddress,
-        });
-
-      const contract = await walletMethods.createContract?.(contractAddress, abi, provider);
-
-      const tx = await contract.getFunction("swapIn").populateTransaction(
-        ...getSwapInParams({
-          streamSwap,
-          toChecksumAddress,
-          contractAddress: contractAddress as AGG_CONTRACT_ADDRESS,
-          recipient,
-          calldata,
-        }),
-        { from },
-      );
-
-      return walletMethods.sendTransaction(tx, feeOptionKey) as Promise<string>;
-    }
-
-    throw new SwapKitError("core_swap_quote_mode_not_supported", { quoteMode });
-  };
-
-  getWalletByChain = async (chain: Chain, potentialScamFilter?: boolean) => {
-    const address = this.getAddress(chain);
-    if (!address) return null;
-    const defaultBalance = [AssetValue.fromChainOrSignature(chain)];
-    const walletType = this.connectedChains[chain]?.walletType as WalletOption;
-
-    try {
-      const balance = await this.getWallet(chain)?.getBalance(address, potentialScamFilter);
-
-      this.connectedChains[chain] = {
-        address,
-        balance: balance?.length ? balance : defaultBalance,
-        walletType,
-      };
-
-      return { ...this.connectedChains[chain] };
-    } catch (error) {
-      console.error(error);
-
-      return { address, balance: defaultBalance, walletType };
-    }
-  };
-
-  approveAssetValue = (assetValue: AssetValue, contractAddress?: string) =>
-    this.#approve({ assetValue, type: "approve", contractAddress });
-
-  isAssetValueApproved = (assetValue: AssetValue, contractAddress?: string) =>
-    this.#approve<boolean>({ assetValue, contractAddress, type: "checkOnly" });
-
-  validateAddress = ({ address, chain }: { address: string; chain: Chain }) =>
-    this.getWallet(chain)?.validateAddress?.(address);
-
-  transfer = async (params: CoreTxParams & { router?: string }) => {
-    const walletInstance = this.connectedWallets[params.assetValue.chain];
-    if (!walletInstance) throw new SwapKitError("core_wallet_connection_not_found");
-
-    try {
-      const tx = await walletInstance.transfer(this.#prepareTxParams(params));
-
-      return tx;
-    } catch (error) {
-      throw new SwapKitError("core_swap_transaction_error", error);
-    }
-  };
-
-  deposit = async ({
-    assetValue,
-    recipient,
-    router,
-    ...rest
-  }: // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor
-  CoreTxParams & { router?: string }) => {
-    const { chain, symbol, ticker } = assetValue;
-    const walletInstance = this.connectedWallets[chain];
-    const connectedWallet = this.connectedChains[chain];
-    const isAddressValidated = await validateAddressType({
-      address: connectedWallet?.address,
-      chain,
-    });
-
-    if (!isAddressValidated) {
-      throw new SwapKitError("core_transaction_invalid_sender_address");
-    }
-    if (!walletInstance) {
-      throw new SwapKitError("core_wallet_connection_not_found");
-    }
-
-    const params = this.#prepareTxParams({
-      assetValue,
-      recipient,
-      router,
-      ...rest,
-    });
-
-    try {
-      switch (chain) {
-        case Chain.THORChain:
-        case Chain.Maya: {
-          const wallet = walletInstance as ThorchainWallet;
-          const tx = await (recipient === "" ? wallet.deposit(params) : wallet.transfer(params));
-          return tx;
-        }
-
-        case Chain.Ethereum:
-        case Chain.BinanceSmartChain:
-        case Chain.Avalanche: {
-          const { getChecksumAddressFromAsset } = await import("@swapkit/toolbox-evm");
-
-          const abi =
-            chain === Chain.Avalanche
-              ? TCAvalancheDepositABI
-              : chain === Chain.BinanceSmartChain
-                ? TCBscDepositABI
-                : TCEthereumVaultAbi;
-
-          const wallet = walletInstance as EVMWallet<
-            typeof AVAXToolbox | typeof ETHToolbox | typeof BSCToolbox
-          >;
-
-          const response = await wallet.call({
-            abi,
-            contractAddress:
-              router || ((await this.#getInboundDataByChain(chain as EVMChain)).router as string),
-            funcName: "depositWithExpiry",
-            funcParams: [
-              recipient,
-              getChecksumAddressFromAsset({ chain, symbol, ticker }, chain),
-              assetValue.getBaseValue("string"),
-              params.memo,
-              rest.expiration ||
-                Number.parseInt(`${(new Date().getTime() + 15 * 60 * 1000) / 1000}`),
-            ],
-            txOverrides: {
-              from: params.from,
-              value: assetValue.isGasAsset ? assetValue.getBaseValue("bigint") : undefined,
-            },
-          });
-
-          return response as string;
-        }
-
-        default: {
-          const tx = await walletInstance.transfer(params);
-          return tx;
-        }
-      }
-    } catch (error) {
-      const errorMessage =
-        // @ts-expect-error - this is fine as we are checking for string
-        typeof error === "string" ? error.toLowerCase() : error?.message?.toLowerCase();
-
-      const isInsufficientFunds = errorMessage?.includes("insufficient funds");
-      const isGas = errorMessage?.includes("gas");
-      const isServer = errorMessage?.includes("server");
-      const isUserRejected = errorMessage?.includes("user rejected");
-      const errorKey: ErrorKeys = isInsufficientFunds
-        ? "core_transaction_deposit_insufficient_funds_error"
-        : isGas
-          ? "core_transaction_deposit_gas_error"
-          : isServer
-            ? "core_transaction_deposit_server_error"
-            : isUserRejected
-              ? "core_transaction_user_rejected"
-              : "core_transaction_deposit_error";
-
-      throw new SwapKitError(errorKey, error);
-    }
-  };
-
-  /**
-   * TC related Methods
-   */
-  createLiquidity = async ({
-    runeAssetValue,
-    assetValue,
-  }: {
-    runeAssetValue: AssetValue;
-    assetValue: AssetValue;
-  }) => {
-    if (runeAssetValue.lte(0) || assetValue.lte(0)) {
-      throw new SwapKitError("core_transaction_create_liquidity_invalid_params");
-    }
-
-    const assetAddress = this.getAddress(assetValue.chain);
-    const runeAddress = this.getAddress(Chain.THORChain);
-
-    const runeTx = await wrapWithThrow(() => {
-      return this.#depositToPool({
-        assetValue: runeAssetValue,
-        memo: getMemoFor(MemoType.DEPOSIT, { ...assetValue, address: assetAddress }),
-      });
-    }, "core_transaction_create_liquidity_rune_error");
-
-    const assetTx = await wrapWithThrow(() => {
-      return this.#depositToPool({
-        assetValue,
-        memo: getMemoFor(MemoType.DEPOSIT, { ...assetValue, address: runeAddress }),
-      });
-    }, "core_transaction_create_liquidity_asset_error");
-
-    return { runeTx, assetTx };
-  };
-
-  addLiquidity = async ({
-    runeAssetValue,
-    assetValue,
-    runeAddr,
-    assetAddr,
-    isPendingSymmAsset,
-    mode = "sym",
-  }: {
-    runeAssetValue: AssetValue;
-    assetValue: AssetValue;
-    isPendingSymmAsset?: boolean;
-    runeAddr?: string;
-    assetAddr?: string;
-    mode?: "sym" | "rune" | "asset";
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor
-  }) => {
-    const { chain, symbol } = assetValue;
-    const isSym = mode === "sym";
-    const runeTransfer = runeAssetValue?.gt(0) && (isSym || mode === "rune");
-    const assetTransfer = assetValue?.gt(0) && (isSym || mode === "asset");
-    const includeRuneAddress = isPendingSymmAsset || runeTransfer;
-    const runeAddress = includeRuneAddress ? runeAddr || this.getAddress(Chain.THORChain) : "";
-    const assetAddress = isSym || mode === "asset" ? assetAddr || this.getAddress(chain) : "";
-
-    if (!(runeTransfer || assetTransfer)) {
-      throw new SwapKitError("core_transaction_add_liquidity_invalid_params");
-    }
-    if (includeRuneAddress && !runeAddress) {
-      throw new SwapKitError("core_transaction_add_liquidity_no_rune_address");
-    }
-
-    const runeTx = await wrapWithThrow(() => {
-      return this.#depositToPool({
-        assetValue: runeAssetValue,
-        memo: getMemoFor(MemoType.DEPOSIT, { chain, symbol, address: assetAddress }),
-      });
-    }, "core_transaction_add_liquidity_rune_error");
-
-    const assetTx =
-      assetTransfer && assetValue
-        ? wrapWithThrow(() => {
-            return this.#depositToPool({
-              assetValue,
-              memo: getMemoFor(MemoType.DEPOSIT, { chain, symbol, address: runeAddress }),
-            });
-          }, "core_transaction_add_liquidity_asset_error")
-        : null;
-
-    return { runeTx, assetTx };
-  };
-
-  addLiquidityPart = ({
-    assetValue,
-    poolAddress,
-    address,
-    symmetric,
-  }: {
-    assetValue: AssetValue;
-    address?: string;
-    poolAddress: string;
-    symmetric: boolean;
-  }) => {
-    if (symmetric && !address) {
-      throw new SwapKitError("core_transaction_add_liquidity_invalid_params");
-    }
-
-    const memo = getMemoFor(MemoType.DEPOSIT, {
-      chain: poolAddress.split(".")[0] as Chain,
-      symbol: poolAddress.split(".")[1] as string,
-      address: symmetric ? address : "",
-    });
-
-    return this.#depositToPool({ assetValue, memo });
-  };
-
-  withdraw = ({
-    memo,
-    assetValue,
-    percent,
-    from,
-    to,
-  }: {
-    memo?: string;
-    assetValue: AssetValue;
-    percent: number;
-    from: "sym" | "rune" | "asset";
-    to: "sym" | "rune" | "asset";
-  }) => {
-    const targetAsset =
-      to === "rune" && from !== "rune"
-        ? AssetValue.fromChainOrSignature(Chain.THORChain)
-        : (from === "sym" && to === "sym") || from === "rune" || from === "asset"
-          ? undefined
-          : assetValue;
-
-    const value = getMinAmountByChain(from === "asset" ? assetValue.chain : Chain.THORChain);
-    const memoString =
-      memo ||
-      getMemoFor(MemoType.WITHDRAW, {
-        symbol: assetValue.symbol,
-        chain: assetValue.chain,
-        ticker: assetValue.ticker,
-        basisPoints: Math.min(10000, Math.round(percent * 100)),
-        targetAssetString: targetAsset?.toString(),
-        singleSide: false,
-      });
-
-    return this.#depositToPool({ assetValue: value, memo: memoString });
-  };
-
-  savings = ({
-    assetValue,
-    memo,
-    percent,
-    type,
-  }: { assetValue: AssetValue; memo?: string } & (
-    | { type: "add"; percent?: undefined }
-    | { type: "withdraw"; percent: number }
-  )) => {
-    const memoType = type === "add" ? MemoType.DEPOSIT : MemoType.WITHDRAW;
-    const memoString =
-      memo ||
-      getMemoFor(memoType, {
-        ticker: assetValue.ticker,
-        symbol: assetValue.symbol,
-        chain: assetValue.chain,
-        singleSide: true,
-        basisPoints: percent ? Math.min(10000, Math.round(percent * 100)) : undefined,
-      });
-
-    const value =
-      memoType === MemoType.DEPOSIT ? assetValue : getMinAmountByChain(assetValue.chain);
-
-    return this.#depositToPool({ memo: memoString, assetValue: value });
-  };
-
-  loan = ({
-    assetValue,
-    memo,
-    minAmount,
-    type,
-  }: {
-    assetValue: AssetValue;
-    memo?: string;
-    minAmount: AssetValue;
-    type: "open" | "close";
-  }) =>
-    this.#depositToPool({
-      assetValue,
-      memo:
-        memo ||
-        getMemoFor(type === "open" ? MemoType.OPEN_LOAN : MemoType.CLOSE_LOAN, {
-          asset: assetValue.toString(),
-          minAmount: minAmount.toString(),
-          address: this.getAddress(assetValue.chain),
-        }),
-    });
-
-  nodeAction = ({
-    type,
-    assetValue,
-    address,
-  }: { address: string } & (
-    | { type: "bond" | "unbond"; assetValue: AssetValue }
-    | { type: "leave"; assetValue?: undefined }
-  )) => {
-    const memoType =
-      type === "bond" ? MemoType.BOND : type === "unbond" ? MemoType.UNBOND : MemoType.LEAVE;
-    const memo = getMemoFor(memoType, {
-      address,
-      unbondAmount: type === "unbond" ? assetValue.getBaseValue("number") : undefined,
-    });
-
-    return this.#thorchainTransfer({
-      memo,
-      assetValue: type === "bond" ? assetValue : getMinAmountByChain(Chain.THORChain),
-    });
-  };
-
-  registerThorname = ({
-    assetValue,
-    ...param
-  }: ThornameRegisterParam & { assetValue: AssetValue }) =>
-    this.#thorchainTransfer({
-      assetValue,
-      memo: getMemoFor(MemoType.THORNAME_REGISTER, param),
-    });
-
-  registerMayaname = ({
-    assetValue,
-    ...param
-  }: ThornameRegisterParam & { assetValue: AssetValue }) =>
-    this.#mayachainTransfer({
-      assetValue,
-      memo: getMemoFor(MemoType.THORNAME_REGISTER, param),
-    });
-
-  extend = ({ wallets, config, apis = {}, rpcUrls = {} }: ExtendParams<T>) => {
-    try {
-      for (const wallet of wallets) {
-        // @ts-expect-error - this is fine as we are extending the class
-        this[wallet.connectMethodName] = wallet.connect({
-          addChain: this.#addConnectedChain,
-          config: config || {},
-          apis,
-          rpcUrls,
-        });
-      }
-    } catch (error) {
-      throw new SwapKitError("core_extend_error", error);
-    }
-  };
-
-  estimateMaxSendableAmount = async ({
-    chain,
-    params,
-  }: {
-    chain: Chain;
-    params: { from: string; recipient: string; assetValue: AssetValue };
-  }) => {
-    const walletMethods = this.getWallet<typeof chain>(chain);
-
-    switch (chain) {
-      case Chain.Arbitrum:
-      case Chain.Avalanche:
-      case Chain.BinanceSmartChain:
-      case Chain.Ethereum:
-      case Chain.Optimism:
-      case Chain.Polygon: {
-        const { estimateMaxSendableAmount } = await import("@swapkit/toolbox-evm");
-        return estimateMaxSendableAmount({
-          ...params,
-          toolbox: walletMethods as EVMToolbox,
-        });
-      }
-
-      case Chain.Bitcoin:
-      case Chain.BitcoinCash:
-      case Chain.Dogecoin:
-      case Chain.Litecoin:
-        return (walletMethods as UTXOToolbox).estimateMaxSendableAmount(params);
-
-      case Chain.Binance:
-      case Chain.THORChain:
-      case Chain.Cosmos: {
-        const { estimateMaxSendableAmount } = await import("@swapkit/toolbox-cosmos");
-        return estimateMaxSendableAmount({
-          ...params,
-          toolbox: walletMethods as CosmosLikeToolbox,
-        });
-      }
-
-      default:
-        throw new SwapKitError("core_estimated_max_spendable_chain_not_supported");
-    }
-  };
-
-  /**
-   * Wallet connection methods
-   */
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectXDEFI = async (_chains: Chain[]): Promise<void> => {
-    throw new SwapKitError("core_wallet_xdefi_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectEVMWallet = async (_chains: Chain[] | Chain, _wallet: EVMWalletOptions): Promise<void> => {
-    throw new SwapKitError("core_wallet_evmwallet_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectWalletconnect = async (_chains: Chain[], _options?: Todo): Promise<void> => {
-    throw new SwapKitError("core_wallet_walletconnect_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectKeepkey = async (_chains: Chain[], _derivationPath: number[][]): Promise<string> => {
-    throw new SwapKitError("core_wallet_keepkey_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectKeystore = async (_chains: Chain[], _phrase: string): Promise<void> => {
-    throw new SwapKitError("core_wallet_keystore_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectLedger = async (_chains: Chain, _derivationPath: number[]): Promise<void> => {
-    throw new SwapKitError("core_wallet_ledger_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectTrezor = async (_chains: Chain, _derivationPath: number[]): Promise<void> => {
-    throw new SwapKitError("core_wallet_trezor_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectKeplr = async (_chain: Chain): Promise<void> => {
-    throw new SwapKitError("core_wallet_keplr_not_installed");
-  };
-  // biome-ignore lint/suspicious/useAwait: Extended methods
-  connectOkx = async (_chains: Chain[]): Promise<void> => {
-    throw new SwapKitError("core_wallet_okx_not_installed");
-  };
-
-  disconnectChain = (chain: Chain) => {
-    this.connectedChains[chain] = null;
-    this.connectedWallets[chain] = null;
-  };
-
-  #getInboundDataByChain = async (chain: Chain) => {
-    switch (chain) {
-      case Chain.Maya:
-      case Chain.THORChain:
-        return { gas_rate: "0", router: "", address: "", halted: false, chain };
-
-      default: {
-        const inboundData = await SwapKitApi.getInboundAddresses({ stagenet: this.stagenet });
-        const chainAddressData = inboundData.find((item) => item.chain === chain);
-
-        if (!chainAddressData) throw new SwapKitError("core_inbound_data_not_found");
-        if (chainAddressData?.halted) throw new SwapKitError("core_chain_halted");
-
-        return chainAddressData;
-      }
-    }
-  };
-
-  #addConnectedChain = ({
-    chain,
-    address,
-    balance,
-    walletType,
-    ...rest
-  }: AddChainWalletParams<Todo>) => {
-    this.connectedChains[chain as Chain] = {
-      address: address || "",
-      balance: balance || [],
-      walletType: walletType || "unknown",
-    };
-    this.connectedWallets[chain as Chain] = { ...rest } as Todo;
-  };
-
-  #approve = async <T = string>({
-    assetValue,
-    type = "checkOnly",
-    contractAddress,
-  }: {
-    assetValue: AssetValue;
-    type?: "checkOnly" | "approve";
-    contractAddress?: string;
-  }) => {
-    const { address, chain, isGasAsset, isSynthetic } = assetValue;
-    const isEVMChain = [Chain.Ethereum, Chain.Avalanche, Chain.BinanceSmartChain].includes(chain);
-    const isNativeEVM = isEVMChain && isGasAsset;
-
-    if (isNativeEVM || !isEVMChain || isSynthetic) return true;
-
-    const walletMethods = this.connectedWallets[chain as EVMChain];
-    const walletAction = type === "checkOnly" ? walletMethods?.isApproved : walletMethods?.approve;
-
-    if (!walletAction) {
-      throw new SwapKitError("core_wallet_connection_not_found");
-    }
-
-    const from = this.getAddress(chain);
-
-    if (!(address && from)) {
-      throw new SwapKitError("core_approve_asset_address_or_from_not_found");
-    }
-
-    const spenderAddress =
-      contractAddress || ((await this.#getInboundDataByChain(chain)).router as string);
-
-    return walletAction({
-      amount: assetValue.getBaseValue("bigint"),
-      assetAddress: address,
-      from,
-      spenderAddress,
-    }) as Promise<T>;
-  };
-
-  #depositToPool = async ({
-    assetValue,
-    memo,
-    feeOptionKey = FeeOption.Fast,
-  }: {
-    assetValue: AssetValue;
-    memo: string;
-    feeOptionKey?: FeeOption;
-  }) => {
-    const {
-      gas_rate = "0",
-      router,
-      address: poolAddress,
-    } = await this.#getInboundDataByChain(assetValue.chain);
-    const feeRate = Number.parseInt(gas_rate) * gasFeeMultiplier[feeOptionKey];
-
-    return this.deposit({
-      assetValue,
-      recipient: poolAddress,
-      memo,
-      router,
-      feeRate,
-    }) as Promise<string>;
-  };
-
-  #thorchainTransfer = async ({
-    memo,
-    assetValue,
-  }: {
-    assetValue: AssetValue;
-    memo: string;
-  }) => {
-    const mimir = await SwapKitApi.getMimirInfo({ stagenet: this.stagenet });
-
-    // check if trading is halted or not
-    if (mimir.HALTCHAINGLOBAL >= 1 || mimir.HALTTHORCHAIN >= 1) {
-      throw new SwapKitError("core_chain_halted");
-    }
-
-    return this.deposit({ assetValue, recipient: "", memo });
-  };
-
-  #mayachainTransfer = async ({
-    memo,
-    assetValue,
-  }: {
-    assetValue: AssetValue;
-    memo: string;
-  }) => {
-    const mimir = await SwapKitApi.getMimirInfo({ type: "mayachain", stagenet: this.stagenet });
-
-    // check if trading is halted or not
-    if (mimir.HALTCHAINGLOBAL >= 1 || mimir.HALTTHORCHAIN >= 1) {
-      throw new SwapKitError("core_chain_halted");
-    }
-
-    return this.deposit({ assetValue, recipient: "", memo });
-  };
-
-  #prepareTxParams = ({ assetValue, ...restTxParams }: CoreTxParams & { router?: string }) => ({
-    ...restTxParams,
-    memo: restTxParams.memo || "",
-    from: this.getAddress(assetValue.chain),
-    assetValue,
-  });
-}