@swapkit/core 1.0.0-rc.10 → 1.0.0-rc.101

package/src/client/index.ts

@@ -1,690 +1,256 @@
-import type { Keys, ThornameRegisterParam } from '@swapkit/helpers';
+import { AssetValue, SwapKitError } from "@swapkit/helpers";
+import { Chain } from "@swapkit/types";
 import {
-  AssetValue,
-  gasFeeMultiplier,
-  getMemoFor,
-  getMinAmountByChain,
-  SwapKitError,
-  SwapKitNumber,
-} 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';
+  getExplorerAddressUrl as getAddressUrl,
+  getExplorerTxUrl as getTxUrl,
+} from "../helpers/explorerUrls.ts";
 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 './explorerUrls.ts';
-import { getInboundData, getMimirData } from './thornode.ts';
-import type {
-  CoreTxParams,
-  EVMWallet,
-  SwapParams,
-  ThorchainWallet,
-  Wallet,
-  WalletMethods,
-} from './types.ts';
-
-const getEmptyWalletStructure = () =>
-  (Object.values(Chain) as Chain[]).reduce(
-    (acc, chain) => {
-      acc[chain] = null;
-      return acc;
-    },
-    {} as Record<Chain, null>,
-  );
-
-export class SwapKitCore<T = ''> {
-  public connectedChains: Wallet = 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, refresh?: boolean) => {
-    if (!refresh) return this.connectedChains[chain]?.balance || [];
-    const wallet = await this.getWalletByChain(chain);
-
-    return wallet?.balance || [];
-  };
-
-  swap = async ({ streamSwap, recipient, route, feeOptionKey }: SwapParams) => {
-    const { quoteMode } = route.meta;
-    const evmChain = quoteMode.startsWith('ERC20-')
-      ? Chain.Ethereum
-      : quoteMode.startsWith('ARC20-')
-      ? Chain.Avalanche
-      : Chain.BinanceSmartChain;
-
-    if (!route.complete) throw new SwapKitError('core_swap_route_not_complete');
-
-    try {
-      if (AGG_SWAP.includes(quoteMode)) {
-        const walletMethods = this.connectedWallets[evmChain];
-        if (!walletMethods?.sendTransaction) {
-          throw new SwapKitError('core_wallet_connection_not_found');
-        }
-
-        const transaction = streamSwap ? route?.streamingSwap?.transaction : route?.transaction;
-        if (!transaction) throw new SwapKitError('core_swap_route_transaction_not_found');
-
-        const { isHexString, parseUnits } = await import('ethers');
-        const { data, from, to, value } = route.transaction;
-
-        const params = {
-          data,
-          from,
-          to: to.toLowerCase(),
-          chainId: BigInt(ChainToChainId[evmChain]),
-          value: value
-            ? new SwapKitNumber({
-                value: !isHexString(value) ? parseUnits(value, 'wei').toString(16) : value,
-              }).baseValueBigInt
-            : 0n,
-        };
-
-        return walletMethods.sendTransaction(params, feeOptionKey) as Promise<string>;
-      }
-
-      if (SWAP_OUT.includes(quoteMode)) {
-        if (!route.calldata.fromAsset) throw new SwapKitError('core_swap_asset_not_recognized');
-        const asset = await AssetValue.fromString(route.calldata.fromAsset);
-        if (!asset) throw new SwapKitError('core_swap_asset_not_recognized');
-
-        const { address: recipient } = await this.#getInboundDataByChain(asset.chain);
-        const {
-          contract: router,
-          calldata: { amountIn, memo, memoStreamingSwap },
-        } = route;
-
-        const assetValue = asset.add(SwapKitNumber.fromBigInt(BigInt(amountIn), asset.decimal));
-        const swapMemo = (streamSwap ? memoStreamingSwap || memo : memo) as string;
-
-        return this.deposit({ assetValue, memo: swapMemo, feeOptionKey, router, recipient });
-      }
-
-      if (SWAP_IN.includes(quoteMode)) {
-        const { calldata, contract: contractAddress } = route;
-        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);
-
-        // TODO: (@Towan) Contract evm methods should be generic
-        // @ts-expect-error
-        const tx = await contract.populateTransaction.swapIn?.(
-          ...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 });
-    } catch (error) {
-      throw new SwapKitError('core_swap_transaction_error', error);
-    }
-  };
+  ChainWallet,
+  ConnectWalletParamsLocal as ConnectWalletParams,
+  SwapWithRouteParams,
+} from "../types.ts";
+
+export type ProviderName = "thorchain" | "chainflip" | "mayachain";
+export enum ApproveMode {
+  Approve = "approve",
+  CheckOnly = "checkOnly",
+}
 
-  getWalletByChain = async (chain: Chain) => {
-    const address = this.getAddress(chain);
-    if (!address) return null;
+export type ApproveReturnType<T extends ApproveMode> = T extends "checkOnly"
+  ? Promise<boolean>
+  : Promise<string>;
 
-    const balance = (await this.getWallet(chain)?.getBalance(address)) ?? [
-      AssetValue.fromChainOrSignature(chain),
-    ];
+type SwapKitProviders = {
+  [K in ProviderName]?: ProviderMethods;
+};
 
-    this.connectedChains[chain] = {
-      address,
-      balance,
-      walletType: this.connectedChains[chain]?.walletType as WalletOption,
-    };
+type GenericSwapParams = {
+  buyAsset: AssetValue;
+  sellAsset: AssetValue;
+  recipient: string;
+};
 
-    return { ...this.connectedChains[chain] };
+export type SwapParams = (SwapWithRouteParams | GenericSwapParams) & {
+  provider?: {
+    name: ProviderName;
+    config: Record<string, any>;
   };
+};
+
+export type SwapKitReturnType = SwapKitProviders & {
+  getAddress: (chain: Chain) => string;
+  getWallet: (chain: Chain) => ChainWallet<Chain> | undefined;
+  getWalletWithBalance: (
+    chain: Chain,
+    potentialScamFilter?: boolean,
+  ) => Promise<ChainWallet<Chain>>;
+  getBalance: (chain: Chain, potentialScamFilter?: boolean) => AssetValue[];
+  getExplorerTxUrl: (chain: Chain, txHash: string) => string;
+  getExplorerAddressUrl: (chain: Chain, address: string) => string;
+  swap: (params: SwapParams) => Promise<string>;
+  validateAddress: (params: { address: string; chain: Chain }) =>
+    | boolean
+    | Promise<boolean>
+    | undefined;
+  approveAssetValue: (assetValue: AssetValue, contractAddress: string) => boolean | Promise<string>;
+  isAssetValueApproved: (
+    assetValue: AssetValue,
+    contractAddress: string,
+  ) => boolean | Promise<boolean>;
+};
+
+export type Wallets = { [K in Chain]?: ChainWallet<K> };
+export type AvailableProviders<T> = T | { [K in ProviderName]?: ProviderMethods };
+export type ProviderMethods = {
+  swap: (swapParams: SwapParams) => Promise<string>;
+  [key: string]: any;
+};
+
+export type SwapKitProvider = ({ wallets, stagenet }: { wallets: Wallets; stagenet?: boolean }) => {
+  name: ProviderName;
+  methods: ProviderMethods;
+};
+
+export type SwapKitWallet = {
+  connectMethodName: string;
+  connect: (params: ConnectWalletParams) => (connectParams: any) => void;
+};
+
+export function SwapKit<
+  ExtendedProviders extends {},
+  ConnectWalletMethods extends Record<string, ReturnType<SwapKitWallet["connect"]>>,
+>({
+  stagenet,
+  wallets,
+  providers,
+  config = {},
+  apis,
+  rpcUrls,
+}: {
+  providers: SwapKitProvider[];
+  stagenet: boolean;
+  wallets: SwapKitWallet[];
+  config?: Record<string, any>;
+  apis: Record<string, any>;
+  rpcUrls: Record<string, any>;
+}): SwapKitReturnType & ConnectWalletMethods & AvailableProviders<ExtendedProviders> {
+  const connectedWallets: Wallets = {};
+  const availableProviders: AvailableProviders<ExtendedProviders> = {};
+
+  for (const provider of providers) {
+    const { name, methods } = provider({ wallets: connectedWallets, stagenet });
+
+    availableProviders[name] = methods;
+  }
 
-  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);
+  const connectWalletMethods = wallets.reduce((acc, wallet) => {
+    (acc[wallet.connectMethodName] as ReturnType<SwapKitWallet["connect"]>) = wallet.connect({
+      addChain,
+      config,
+      apis,
+      rpcUrls,
+    });
 
-  transfer = async (params: CoreTxParams & { router?: string }) => {
-    const walletInstance = this.connectedWallets[params.assetValue.chain];
-    if (!walletInstance) throw new SwapKitError('core_wallet_connection_not_found');
+    return acc;
+  }, {} as ConnectWalletMethods);
 
-    try {
-      return await walletInstance.transfer(this.#prepareTxParams(params));
-    } catch (error) {
-      throw new SwapKitError('core_swap_transaction_error', error);
+  /**
+   * @Private
+   * Internal helpers
+   */
+  function getProvider(providerName?: ProviderName) {
+    const provider =
+      (availableProviders as SwapKitProviders)[providerName as ProviderName] ||
+      Object.values(availableProviders)[0];
+
+    if (!provider) {
+      throw new SwapKitError(
+        "core_swap_provider_not_found",
+        "Could not find the requested provider",
+      );
     }
-  };
 
-  deposit = async ({
-    assetValue,
-    recipient,
-    router,
-    ...rest
-  }: CoreTxParams & { router?: string }) => {
-    const { chain, symbol, ticker } = assetValue;
-    const walletInstance = this.connectedWallets[chain];
-    if (!walletInstance) throw new SwapKitError('core_wallet_connection_not_found');
-
-    const params = this.#prepareTxParams({ assetValue, recipient, router, ...rest });
+    return provider;
+  }
 
-    try {
-      switch (chain) {
-        case Chain.THORChain: {
-          const wallet = walletInstance as ThorchainWallet;
-          return await (recipient === '' ? wallet.deposit(params) : wallet.transfer(params));
-        }
-
-        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;
-
-          return (await (
-            walletInstance as EVMWallet<typeof AVAXToolbox | typeof ETHToolbox | typeof BSCToolbox>
-          ).call({
-            abi,
-            contractAddress:
-              router || ((await this.#getInboundDataByChain(chain as EVMChain)).router as string),
-            funcName: 'depositWithExpiry',
-            funcParams: [
-              recipient,
-              getChecksumAddressFromAsset({ chain, symbol, ticker }, chain),
-              // TODO: (@Towan) Re-Check on that conversion 🙏
-              assetValue.baseValueBigInt.toString(),
-              params.memo,
-              rest.expiration,
-            ],
-            txOverrides: { from: params.from, value: assetValue.baseValueBigInt },
-          })) as Promise<string>;
-        }
-
-        default: {
-          return await walletInstance.transfer(params);
-        }
-      }
-    } catch (error: any) {
-      const errorMessage = (error?.message || error?.toString()).toLowerCase();
-      const isInsufficientFunds = errorMessage?.includes('insufficient funds');
-      const isGas = errorMessage?.includes('gas');
-      const isServer = errorMessage?.includes('server');
-      const errorKey: Keys = isInsufficientFunds
-        ? 'core_transaction_deposit_insufficient_funds_error'
-        : isGas
-        ? 'core_transaction_deposit_gas_error'
-        : isServer
-        ? 'core_transaction_deposit_server_error'
-        : 'core_transaction_deposit_error';
-
-      throw new SwapKitError(errorKey, error);
-    }
-  };
+  function addChain(connectWallet: ChainWallet<Chain>) {
+    (connectedWallets[connectWallet.chain as Chain] as ChainWallet<Chain>) = connectWallet;
+  }
 
   /**
-   * TC related Methods
+   * @Private
+   * Wallet interaction helpers
    */
-  createLiquidity = async ({
-    runeAssetValue,
+  function approve<T extends ApproveMode>({
     assetValue,
+    type = "checkOnly" as T,
+    contractAddress,
   }: {
-    runeAssetValue: AssetValue;
+    type: T;
     assetValue: AssetValue;
-  }) => {
-    if (runeAssetValue.lte(0) || assetValue.lte(0)) {
-      throw new SwapKitError('core_transaction_create_liquidity_invalid_params');
-    }
-
-    let runeTx = '';
-    let assetTx = '';
-
-    try {
-      runeTx = await this.#depositToPool({
-        assetValue: runeAssetValue,
-        memo: getMemoFor(MemoType.DEPOSIT, {
-          ...assetValue,
-          address: this.getAddress(assetValue.chain),
-        }),
-      });
-    } catch (error) {
-      throw new SwapKitError('core_transaction_create_liquidity_rune_error', error);
-    }
+    contractAddress: string;
+  }): ApproveReturnType<T> {
+    const { address, chain, isGasAsset, isSynthetic } = assetValue;
+    const isEVMChain = [Chain.Ethereum, Chain.Avalanche, Chain.BinanceSmartChain].includes(chain);
+    const isNativeEVM = isEVMChain && isGasAsset;
 
-    try {
-      assetTx = await this.#depositToPool({
-        assetValue,
-        memo: getMemoFor(MemoType.DEPOSIT, {
-          ...assetValue,
-          address: this.getAddress(Chain.THORChain),
-        }),
-      });
-    } catch (error) {
-      throw new SwapKitError('core_transaction_create_liquidity_asset_error', error);
+    if (isNativeEVM || !isEVMChain || isSynthetic) {
+      return Promise.resolve(type === "checkOnly" ? true : "approved") as ApproveReturnType<T>;
     }
 
-    return { runeTx, assetTx };
-  };
+    const walletMethods =
+      connectedWallets[chain as Chain.Ethereum | Chain.BinanceSmartChain | Chain.Avalanche];
 
-  addLiquidity = async ({
-    poolIdentifier,
-    runeAssetValue,
-    assetValue,
-    runeAddr,
-    assetAddr,
-    isPendingSymmAsset,
-    mode = 'sym',
-  }: {
-    poolIdentifier: string;
-    runeAssetValue: AssetValue;
-    assetValue: AssetValue;
-    isPendingSymmAsset?: boolean;
-    runeAddr?: string;
-    assetAddr?: string;
-    mode?: 'sym' | 'rune' | 'asset';
-  }) => {
-    const [chain, ...symbolPath] = poolIdentifier.split('.') as [Chain, string];
-    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');
-    }
-
-    let runeTx, assetTx;
-    const sharedParams = { chain, symbol: symbolPath.join('.') };
-
-    if (runeTransfer && runeAssetValue) {
-      try {
-        runeTx = await this.#depositToPool({
-          assetValue: runeAssetValue,
-          memo: getMemoFor(MemoType.DEPOSIT, { ...sharedParams, address: assetAddress }),
-        });
-      } catch (error) {
-        throw new SwapKitError('core_transaction_add_liquidity_rune_error', error);
-      }
-    }
+    const walletAction = type === "checkOnly" ? walletMethods?.isApproved : walletMethods?.approve;
 
-    if (assetTransfer && assetValue) {
-      try {
-        assetTx = await this.#depositToPool({
-          assetValue,
-          memo: getMemoFor(MemoType.DEPOSIT, { ...sharedParams, address: runeAddress }),
-        });
-      } catch (error) {
-        throw new SwapKitError('core_transaction_add_liquidity_asset_error', error);
-      }
-    }
+    if (!walletAction) throw new SwapKitError("core_wallet_connection_not_found");
 
-    return { runeTx, assetTx };
-  };
+    const from = getAddress(chain);
 
-  withdraw = async ({
-    memo,
-    assetValue,
-    percent,
-    from,
-    to,
-  }: {
-    memo?: string;
-    assetValue: AssetValue;
-    percent: number;
-    from: 'sym' | 'rune' | 'asset';
-    to: 'sym' | 'rune' | 'asset';
-  }) => {
-    const targetAsset =
-      to === 'rune'
-        ? AssetValue.fromChainOrSignature(Chain.THORChain)
-        : (from === 'sym' && to === 'sym') || from === 'rune' || from === 'asset'
-        ? undefined
-        : assetValue;
+    if (!(address && from)) throw new SwapKitError("core_approve_asset_address_or_from_not_found");
 
-    try {
-      const txHash = await this.#depositToPool({
-        assetValue: getMinAmountByChain(from === 'asset' ? assetValue.chain : Chain.THORChain),
-        memo:
-          memo ||
-          getMemoFor(MemoType.WITHDRAW, {
-            symbol: assetValue.symbol,
-            chain: assetValue.chain,
-            ticker: assetValue.ticker,
-            basisPoints: Math.max(10000, Math.round(percent * 100)),
-            targetAssetString: targetAsset?.toString(),
-            singleSide: false,
-          }),
-      });
-
-      return txHash;
-    } catch (error) {
-      throw new SwapKitError('core_transaction_withdraw_error', error);
-    }
-  };
+    const spenderAddress = contractAddress;
 
-  savings = async ({
-    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.max(10000, Math.round(percent * 100)) : undefined,
-      });
-
-    return this.#depositToPool({ assetValue, memo: memoString });
-  };
+    return walletAction({
+      amount: assetValue.getBaseValue("bigint"),
+      assetAddress: address,
+      from,
+      spenderAddress,
+    }) as ApproveReturnType<T>;
+  }
 
-  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),
-        }),
-    });
+  /**
+   * @Public
+   * Wallet helpers
+   */
+  function getWallet(chain: Chain) {
+    return connectedWallets[chain];
+  }
+  function getAddress(chain: Chain) {
+    return getWallet(chain)?.address || "";
+  }
+  function getBalance(chain: Chain) {
+    return getWallet(chain)?.balance || [];
+  }
+  function getExplorerTxUrl(chain: Chain, txHash: string) {
+    return getTxUrl({ chain, txHash });
+  }
+  function getExplorerAddressUrl(chain: Chain, address: string) {
+    return getAddressUrl({ chain, address });
+  }
+  /**
+   * TODO: Figure out validation without connecting to wallet
+   */
+  function validateAddress({ address, chain }: { address: string; chain: Chain }) {
+    return getWallet(chain)?.validateAddress?.(address);
+  }
 
-  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.baseValueNumber : undefined,
-    });
+  async function getWalletWithBalance(chain: Chain, potentialScamFilter?: boolean) {
+    const defaultBalance = [AssetValue.fromChainOrSignature(chain)];
+    const wallet = getWallet(chain);
 
-    return this.#thorchainTransfer({
-      memo,
-      assetValue: type === 'bond' ? assetValue : getMinAmountByChain(Chain.THORChain),
-    });
-  };
+    try {
+      if (!wallet) throw new SwapKitError("core_wallet_connection_not_found");
+      const balance = await wallet?.getBalance(wallet.address, potentialScamFilter);
 
-  registerThorname = ({
-    assetValue,
-    ...param
-  }: ThornameRegisterParam & { assetValue: AssetValue }) =>
-    this.#thorchainTransfer({ assetValue, memo: getMemoFor(MemoType.THORNAME_REGISTER, param) });
+      wallet.balance = balance?.length ? balance : defaultBalance;
 
-  extend = ({ wallets, config, apis = {}, rpcUrls = {} }: ExtendParams<T>) => {
-    try {
-      wallets.forEach((wallet) => {
-        // @ts-expect-error ANCHOR - Not Worth
-        this[wallet.connectMethodName] = wallet.connect({
-          addChain: this.#addConnectedChain,
-          config: config || {},
-          apis,
-          rpcUrls,
-        });
-      });
+      return wallet;
     } catch (error) {
-      throw new SwapKitError('core_extend_error', error);
+      throw new SwapKitError("core_wallet_connection_not_found", 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
+   * @Public
+   * Wallet interaction methods
    */
-  connectXDEFI = async (_chains: Chain[]): Promise<void> => {
-    throw new SwapKitError('core_wallet_xdefi_not_installed');
-  };
-  connectEVMWallet = async (_chains: Chain[] | Chain, _wallet: EVMWalletOptions): Promise<void> => {
-    throw new SwapKitError('core_wallet_evmwallet_not_installed');
-  };
-  connectWalletconnect = async (_chains: Chain[], _options?: any): Promise<void> => {
-    throw new SwapKitError('core_wallet_walletconnect_not_installed');
-  };
-  connectKeystore = async (_chains: Chain[], _phrase: string): Promise<void> => {
-    throw new SwapKitError('core_wallet_keystore_not_installed');
-  };
-  connectLedger = async (_chains: Chain, _derivationPath: number[]): Promise<void> => {
-    throw new SwapKitError('core_wallet_ledger_not_installed');
-  };
-  connectTrezor = async (_chains: Chain, _derivationPath: number[]): Promise<void> => {
-    throw new SwapKitError('core_wallet_trezor_not_installed');
-  };
-  connectKeplr = async (_chain: Chain): Promise<void> => {
-    throw new SwapKitError('core_wallet_keplr_not_installed');
-  };
-  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) => {
-    if (chain === Chain.THORChain) {
-      return {
-        gas_rate: '0',
-        router: '0',
-        address: '',
-        halted: false,
-        chain: Chain.THORChain,
-      };
-    }
-    const inboundData = await getInboundData(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, wallet, walletMethods }: AddChainWalletParams) => {
-    this.connectedChains[chain] = wallet;
-    this.connectedWallets[chain] = walletMethods;
-  };
-
-  #approve = async <T = string>({
-    assetValue: { baseValueBigInt, address, chain, isGasAsset, isSynthetic },
-    type = 'checkOnly',
-    contractAddress,
-  }: {
-    assetValue: AssetValue;
-    type?: 'checkOnly' | 'approve';
-    contractAddress?: string;
-  }) => {
-    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: baseValueBigInt,
-      assetAddress: address,
-      from,
-      spenderAddress,
-    }) as Promise<T>;
-  };
+  function approveAssetValue(assetValue: AssetValue, contractAddress: string) {
+    return approve({ assetValue, contractAddress, type: ApproveMode.Approve });
+  }
 
-  #depositToPool = async ({
-    assetValue,
-    memo,
-    feeOptionKey = FeeOption.Fast,
-  }: {
-    assetValue: AssetValue;
-    memo: string;
-    feeOptionKey?: FeeOption;
-  }) => {
-    const {
-      gas_rate,
-      router,
-      address: poolAddress,
-    } = await this.#getInboundDataByChain(assetValue.chain);
-    const feeRate = (parseInt(gas_rate) || 0) * gasFeeMultiplier[feeOptionKey];
-
-    return this.deposit({
-      assetValue,
-      recipient: poolAddress,
-      memo,
-      router,
-      feeRate,
-    });
-  };
+  function isAssetValueApproved(assetValue: AssetValue, contractAddress: string) {
+    return approve({ assetValue, contractAddress, type: ApproveMode.CheckOnly });
+  }
 
-  #thorchainTransfer = async ({ memo, assetValue }: { assetValue: AssetValue; memo: string }) => {
-    const mimir = await getMimirData(this.stagenet);
+  function swap({ provider: providerConfig, ...rest }: SwapParams) {
+    const provider = getProvider(providerConfig?.name);
 
-    // check if trading is halted or not
-    if (mimir['HALTCHAINGLOBAL'] >= 1 || mimir['HALTTHORCHAIN'] >= 1) {
-      throw new SwapKitError('core_chain_halted');
-    }
+    return provider.swap({ provider: providerConfig, ...rest });
+  }
 
-    return this.deposit({ assetValue, recipient: '', memo });
+  return {
+    ...availableProviders,
+    ...connectWalletMethods,
+    approveAssetValue,
+    getAddress,
+    getBalance,
+    getExplorerAddressUrl,
+    getExplorerTxUrl,
+    getWallet,
+    getWalletWithBalance,
+    isAssetValueApproved,
+    swap,
+    validateAddress,
   };
-
-  #prepareTxParams = ({ assetValue, ...restTxParams }: CoreTxParams & { router?: string }) => ({
-    ...restTxParams,
-    memo: restTxParams.memo || '',
-    from: this.getAddress(assetValue.chain),
-    assetValue,
-  });
 }