@swapkit/wallets 4.0.0-beta.50 → 4.0.0-beta.52

package/src/onekey/index.ts

@@ -115,10 +115,12 @@ async function getWalletMethodsForExtension(chain: Chain) {
     }
 
     case Chain.Arbitrum:
+    case Chain.Aurora:
     case Chain.Avalanche:
     case Chain.Base:
     case Chain.BinanceSmartChain:
     case Chain.Ethereum:
+    case Chain.Gnosis:
     case Chain.Optimism:
     case Chain.Polygon: {
       const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
@@ -172,11 +174,13 @@ export const onekeyWallet = createWallet({
   walletType: WalletOption.ONEKEY,
   supportedChains: [
     Chain.Arbitrum,
+    Chain.Aurora,
     Chain.Avalanche,
     Chain.Base,
     Chain.BinanceSmartChain,
     Chain.Bitcoin,
     Chain.Ethereum,
+    Chain.Gnosis,
     Chain.Optimism,
     Chain.Polygon,
     Chain.Solana,

package/src/trezor/index.ts

@@ -32,13 +32,15 @@ async function getTrezorWallet<T extends Chain>({
   derivationPath,
 }: { chain: T; derivationPath: DerivationPathArray }) {
   switch (chain) {
-    case Chain.BinanceSmartChain:
-    case Chain.Avalanche:
     case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
+    case Chain.Aurora:
+    case Chain.Avalanche:
     case Chain.Base:
-    case Chain.Ethereum: {
+    case Chain.BinanceSmartChain:
+    case Chain.Ethereum:
+    case Chain.Gnosis:
+    case Chain.Optimism:
+    case Chain.Polygon: {
       const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
       const { getEVMSigner } = await import("./evmSigner");
 
@@ -205,6 +207,7 @@ export const trezorWallet = createWallet({
   walletType: WalletOption.TREZOR,
   supportedChains: [
     Chain.Arbitrum,
+    Chain.Aurora,
     Chain.Avalanche,
     Chain.Base,
     Chain.BinanceSmartChain,
@@ -213,6 +216,7 @@ export const trezorWallet = createWallet({
     Chain.Dash,
     Chain.Dogecoin,
     Chain.Ethereum,
+    Chain.Gnosis,
     Chain.Litecoin,
     Chain.Optimism,
     Chain.Polygon,

package/src/types.ts

@@ -29,9 +29,22 @@ import type { polkadotWallet } from "./polkadotjs";
 import type { radixWallet } from "./radix";
 import type { talismanWallet } from "./talisman";
 import type { trezorWallet } from "./trezor";
+import type { vultisigWallet } from "./vultisig";
 import type { walletconnectWallet } from "./walletconnect";
 import type { xamanWallet } from "./xaman";
 
+export type Callback = (
+  error: Error | null,
+  result?: any, // https://github.com/vultisig/vultisig-windows/blob/baeb3e8099a0003404f9664c43b0183c26029041/clients/extension/src/utils/interfaces.ts#L11
+) => void;
+
+export type VultisigCosmosProvider = {
+  request(
+    request: { method: string; params?: any[] | Record<string, any> },
+    callback?: Callback,
+  ): Promise<any>;
+};
+
 export type SKWallets = {
   [WalletOption.BITGET]: typeof bitgetWallet;
   [WalletOption.BRAVE]: typeof evmWallet;
@@ -58,6 +71,7 @@ export type SKWallets = {
   [WalletOption.TALISMAN]: typeof talismanWallet;
   [WalletOption.TREZOR]: typeof trezorWallet;
   [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet;
+  [WalletOption.VULTISIG]: typeof vultisigWallet;
   [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
   [WalletOption.XAMAN]: typeof xamanWallet;
 };
@@ -90,6 +104,7 @@ export type SKWalletsSupportedChains = {
   [WalletOption.TALISMAN]: typeof talismanWallet.connectTalisman.supportedChains;
   [WalletOption.TREZOR]: typeof trezorWallet.connectTrezor.supportedChains;
   [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.VULTISIG]: typeof vultisigWallet.connectVultisig.supportedChains;
   [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
   [WalletOption.XAMAN]: typeof xamanWallet.connectXaman.supportedChains;
 };
@@ -129,6 +144,23 @@ declare global {
       near: NearBrowserWalletProvider;
     };
 
+    vultisig?: {
+      bitcoin: Eip1193Provider;
+      bitcoincash: Eip1193Provider;
+      dogecoin: Eip1193Provider;
+      ethereum: Eip1193Provider;
+      keplr: Keplr;
+      cosmos: VultisigCosmosProvider;
+      litecoin: Eip1193Provider;
+      thorchain: Eip1193Provider;
+      mayachain: Eip1193Provider;
+      solana: SolanaProvider;
+      polkadot: Eip1193Provider;
+      ripple: Eip1193Provider;
+      dash: Eip1193Provider;
+      zcash: Eip1193Provider;
+    };
+
     bitkeep?: {
       unisat: {
         requestAccounts: () => Promise<[string, ...string[]]>;

package/src/utils.ts

@@ -15,6 +15,7 @@ export async function loadWallet<W extends WalletOption>(walletOption: W): Promi
     .with(WalletOption.COINBASE_MOBILE, async () => (await import("./coinbase")).coinbaseWallet)
     .with(WalletOption.BITGET, async () => (await import("./bitget")).bitgetWallet)
     .with(WalletOption.CTRL, async () => (await import("./ctrl")).ctrlWallet)
+    .with(WalletOption.VULTISIG, async () => (await import("./vultisig")).vultisigWallet)
     .with(WalletOption.OKX, async () => (await import("./okx")).okxWallet)
     .with(WalletOption.ONEKEY, async () => (await import("./onekey")).onekeyWallet)
     .with(WalletOption.EXODUS, async () => (await import("./exodus")).exodusWallet)

package/src/vultisig/index.ts

@@ -0,0 +1,199 @@
+import {
+  Chain,
+  type EVMChain,
+  type GenericTransferParams,
+  SwapKitError,
+  type UTXOChain,
+  UTXOChains,
+  WalletOption,
+  createWallet,
+  filterSupportedChains,
+} from "@swapkit/helpers";
+
+import { getWalletSupportedChains } from "../utils";
+import {
+  getVultisigAddress,
+  getVultisigMethods,
+  getVultisigProvider,
+  prepareNetworkSwitchCosmos,
+  walletTransfer,
+} from "./walletHelpers";
+
+export const vultisigWallet = createWallet({
+  name: "connectVultisig",
+  walletType: WalletOption.VULTISIG,
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.BitcoinCash,
+    Chain.Cosmos,
+    Chain.Dash,
+    Chain.Dogecoin,
+    Chain.Ethereum,
+    Chain.Kujira,
+    Chain.Litecoin,
+    Chain.Maya,
+    Chain.Optimism,
+    Chain.Polkadot,
+    Chain.Polygon,
+    Chain.Ripple,
+    Chain.Solana,
+    Chain.THORChain,
+    Chain.Zcash,
+  ],
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectVultisig(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      const promises = filteredChains
+        .filter((chain) => chain !== Chain.Cosmos && chain !== Chain.Kujira)
+        .map(async (chain) => {
+          const address = await getVultisigAddress(chain);
+          const walletMethods = await getWalletMethods(chain);
+
+          addChain({ ...walletMethods, address, chain, walletType });
+        });
+
+      const cosmosIncluded = filteredChains.includes(Chain.Cosmos);
+      const kujiraIncluded = filteredChains.includes(Chain.Kujira);
+
+      // Race condition single cosmos provider exposed.
+      if (cosmosIncluded) {
+        const addressCosmos = await getVultisigAddress(Chain.Cosmos);
+        const walletMethodsCosmos = await getWalletMethods(Chain.Cosmos);
+        addChain({
+          ...walletMethodsCosmos,
+          address: addressCosmos,
+          chain: Chain.Cosmos,
+          walletType,
+        });
+      }
+      if (kujiraIncluded) {
+        const addressKujira = await getVultisigAddress(Chain.Kujira);
+        const walletMethodsKujira = await getWalletMethods(Chain.Kujira);
+        addChain({
+          ...walletMethodsKujira,
+          address: addressKujira,
+          chain: Chain.Kujira,
+          walletType,
+        });
+      }
+      //--//
+
+      await Promise.all(promises);
+
+      return true;
+    },
+});
+
+export const VULTISIG_SUPPORTED_CHAINS = getWalletSupportedChains(vultisigWallet);
+
+async function getWalletMethods(chain: (typeof VULTISIG_SUPPORTED_CHAINS)[number]) {
+  const { match } = await import("ts-pattern");
+  return match(chain)
+    .with(Chain.Solana, async () => {
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
+      const solanaProvider = window.vultisig?.solana;
+      if (!solanaProvider) throw new SwapKitError("wallet_vultisig_not_found");
+      const toolbox = await getSolanaToolbox({ signer: solanaProvider });
+      return { ...toolbox };
+    })
+
+    .with(Chain.Maya, Chain.THORChain, async () => {
+      const { getCosmosToolbox, THORCHAIN_GAS_VALUE, MAYA_GAS_VALUE } = await import(
+        "@swapkit/toolboxes/cosmos"
+      );
+      const gasLimit = chain === Chain.Maya ? MAYA_GAS_VALUE : THORCHAIN_GAS_VALUE;
+      const toolbox = await getCosmosToolbox(chain as Chain.Cosmos | Chain.Kujira);
+      return {
+        ...toolbox,
+        deposit: (tx: GenericTransferParams) =>
+          walletTransfer({ ...tx, recipient: "" }, "deposit_transaction"),
+        transfer: (tx: GenericTransferParams) =>
+          walletTransfer({ ...tx, gasLimit }, "send_transaction"),
+      };
+    })
+
+    .with(Chain.Cosmos, Chain.Kujira, async () => {
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
+      const provider = await getVultisigProvider(chain as Chain.Cosmos | Chain.Kujira);
+      const toolbox = await getCosmosToolbox(chain as Chain.Cosmos | Chain.Kujira);
+      return prepareNetworkSwitchCosmos({
+        provider,
+        chain,
+        toolbox: {
+          ...toolbox,
+          transfer: walletTransfer,
+        },
+      });
+    })
+
+    .with(...UTXOChains, async () => {
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const toolbox = await getUtxoToolbox(chain as UTXOChain);
+      return { ...toolbox, transfer: walletTransfer };
+    })
+
+    .with(
+      Chain.Arbitrum,
+      Chain.Avalanche,
+      Chain.Base,
+      Chain.BinanceSmartChain,
+      Chain.Ethereum,
+      Chain.Optimism,
+      Chain.Polygon,
+      async () => {
+        const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@swapkit/helpers");
+        const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+        const { BrowserProvider } = await import("ethers");
+        const ethereumWindowProvider = await getVultisigProvider(chain as EVMChain);
+
+        if (!ethereumWindowProvider) {
+          throw new SwapKitError("wallet_vultisig_not_found");
+        }
+
+        const provider = new BrowserProvider(ethereumWindowProvider, "any");
+        const signer = await provider.getSigner();
+        const toolbox = await getEvmToolbox(chain as EVMChain, { provider, signer });
+        const vultisigMethods = getVultisigMethods(provider, chain as EVMChain);
+
+        try {
+          if (chain !== Chain.Ethereum) {
+            const networkParams = toolbox.getNetworkParams();
+            await switchEVMWalletNetwork(provider, chain, networkParams);
+          }
+        } catch (_error) {
+          throw new SwapKitError({
+            errorKey: "wallet_failed_to_add_or_switch_network",
+            info: { wallet: WalletOption.VULTISIG, chain },
+          });
+        }
+
+        return prepareNetworkSwitch({
+          provider,
+          chain,
+          toolbox: {
+            ...toolbox,
+            ...vultisigMethods,
+          },
+        });
+      },
+    )
+
+    .with(Chain.Ripple, async () => {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+      const toolbox = await getRippleToolbox();
+      return { ...toolbox, transfer: walletTransfer };
+    })
+
+    .with(Chain.Polkadot, async () => {
+      const { getSubstrateToolbox } = await import("@swapkit/toolboxes/substrate");
+      const toolbox = await getSubstrateToolbox(chain as Chain.Polkadot);
+      return { ...toolbox, transfer: walletTransfer };
+    })
+
+    .otherwise(async () => null);
+}

package/src/vultisig/walletHelpers.ts

@@ -0,0 +1,359 @@
+import {
+  type AssetValue,
+  Chain,
+  ChainToChainId,
+  type EVMChain,
+  EVMChains,
+  type FeeOption,
+  type NetworkParams,
+  SwapKitError,
+  type UTXOChain,
+  WalletOption,
+  providerRequest,
+} from "@swapkit/helpers";
+import { erc20ABI } from "@swapkit/helpers/contracts";
+import type { getCosmosToolbox } from "@swapkit/toolboxes/cosmos";
+import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
+import type { SolanaProvider } from "@swapkit/toolboxes/solana";
+import type { BrowserProvider, Eip1193Provider } from "ethers";
+import type { VultisigCosmosProvider } from "../types";
+
+type TransactionMethod = "send_transaction" | "deposit_transaction";
+
+type TransactionParams = {
+  asset: string | { chain: string; symbol: string; ticker: string };
+  amount: number | string | { amount: number; decimals?: number };
+  decimal?: number;
+  to: string;
+  data?: string;
+  from?: string;
+};
+
+export type WalletTxParams = {
+  feeOptionKey?: FeeOption;
+  from?: string;
+  memo?: string;
+  recipient: string;
+  assetValue: AssetValue;
+  gasLimit?: string | bigint;
+};
+
+type VultisigProviderType<T> = T extends Chain.Solana
+  ? SolanaProvider
+  : T extends Chain.Cosmos | Chain.Kujira
+    ? VultisigCosmosProvider
+    : T extends EVMChain
+      ? Eip1193Provider
+      : T extends Chain.Maya | Chain.THORChain | Chain.Ripple | Chain.Polkadot | UTXOChain
+        ? Eip1193Provider
+        : undefined;
+
+export async function getVultisigProvider<T extends Chain>(
+  chain: T,
+): Promise<VultisigProviderType<T>> {
+  if (!window.vultisig) throw new SwapKitError("wallet_vultisig_not_found");
+  const { match } = await import("ts-pattern");
+
+  return match(chain as Chain)
+    .with(...EVMChains, () => window.vultisig?.ethereum as Eip1193Provider)
+    .with(Chain.Cosmos, Chain.Kujira, () => window.vultisig?.cosmos as VultisigCosmosProvider)
+    .with(Chain.Bitcoin, () => window.vultisig?.bitcoin as Eip1193Provider)
+    .with(Chain.BitcoinCash, () => window.vultisig?.bitcoincash as Eip1193Provider)
+    .with(Chain.Dash, () => window.vultisig?.dash as Eip1193Provider)
+    .with(Chain.Dogecoin, () => window.vultisig?.dogecoin as Eip1193Provider)
+    .with(Chain.Litecoin, () => window.vultisig?.litecoin as Eip1193Provider)
+    .with(Chain.Solana, () => window.vultisig?.solana as SolanaProvider)
+    .with(Chain.THORChain, () => window.vultisig?.thorchain as Eip1193Provider)
+    .with(Chain.Maya, () => window.vultisig?.mayachain as Eip1193Provider)
+    .with(Chain.Polkadot, () => window.vultisig?.polkadot as Eip1193Provider)
+    .with(Chain.Ripple, () => window.vultisig?.ripple as Eip1193Provider)
+    .with(Chain.Zcash, () => window.vultisig?.zcash as Eip1193Provider)
+    .otherwise(() => undefined) as VultisigProviderType<T>;
+}
+
+async function transaction({
+  method,
+  params,
+  chain,
+}: {
+  method: TransactionMethod;
+  params: TransactionParams[];
+  chain: Chain;
+}): Promise<string> {
+  const client = await getVultisigProvider(chain);
+  let finalParams:
+    | TransactionParams[]
+    | {
+        from: string;
+        to?: string;
+        value: string;
+        data?: string;
+      }[] = params;
+
+  if (chain === Chain.Cosmos || chain === Chain.Kujira || chain === Chain.Ripple) {
+    finalParams = params.map((p) => ({
+      from: p.from as string,
+      to: p.to as string,
+      value: (p.amount as { amount: number; decimals?: number }).amount.toString(),
+      data: p.data as string,
+    }));
+  }
+
+  return new Promise<string>((resolve, reject) => {
+    if (client && "request" in client) {
+      // @ts-ignore
+      client.request({ method, params: finalParams }, (err: string, tx: string) => {
+        err ? reject(err) : resolve(tx);
+      });
+    }
+  });
+}
+
+export async function getVultisigAddress(chain: Chain) {
+  try {
+    const eipProvider = (await getVultisigProvider(chain)) as Eip1193Provider;
+    if (!eipProvider) {
+      throw new SwapKitError({
+        errorKey: "wallet_provider_not_found",
+        info: { wallet: WalletOption.VULTISIG, chain },
+      });
+    }
+
+    if ([Chain.Cosmos, Chain.Kujira].includes(chain)) {
+      const provider = await getVultisigProvider(Chain.Cosmos);
+      const chainId = ChainToChainId[chain];
+
+      await provider.request({
+        method: "wallet_switch_chain",
+        params: [{ chainId }],
+      });
+
+      let account = await provider.request({
+        method: "get_accounts",
+      });
+      if (!account) {
+        const connectedAcount = await provider.request({
+          method: "request_accounts",
+        });
+        account = connectedAcount[0].address;
+      }
+      return account;
+    }
+
+    if (EVMChains.includes(chain as EVMChain)) {
+      if ("request" in eipProvider && typeof eipProvider.request === "function") {
+        const accounts = await eipProvider.request({ method: "eth_requestAccounts" });
+        return accounts[0];
+      }
+      const { BrowserProvider } = await import("ethers");
+      const provider = new BrowserProvider(eipProvider, "any");
+      const [response] = await providerRequest({
+        provider,
+        method: "eth_requestAccounts",
+        params: [],
+      });
+      return response;
+    }
+
+    if (chain === Chain.Solana) {
+      const provider = await getVultisigProvider(Chain.Solana);
+
+      const accounts = await provider.connect();
+      return accounts.publicKey.toString();
+    }
+
+    const accounts = await eipProvider.request({ method: "request_accounts", params: [] });
+    return accounts[0];
+  } catch (_error) {
+    throw new SwapKitError({
+      errorKey: "wallet_provider_not_found",
+      info: { wallet: WalletOption.VULTISIG, chain },
+    });
+  }
+}
+
+export async function walletTransfer(
+  { assetValue, recipient, memo, gasLimit }: WalletTxParams,
+  method: TransactionMethod = "send_transaction",
+) {
+  if (!assetValue) {
+    throw new SwapKitError("wallet_vultisig_asset_not_defined");
+  }
+
+  /**
+   * EVM requires amount to be hex string
+   * UTXO/Cosmos requires amount to be number
+   */
+
+  const from = await getVultisigAddress(assetValue.chain);
+  const params = [
+    {
+      amount: {
+        amount: assetValue.getBaseValue("number"),
+        decimals: assetValue.decimal,
+      },
+      asset: {
+        chain: assetValue.chain,
+        symbol: assetValue.symbol.toUpperCase(),
+        ticker: assetValue.symbol.toUpperCase(),
+      },
+      data: memo || "",
+      from,
+      to: recipient,
+      gasLimit,
+    },
+  ];
+
+  return transaction({ method, params, chain: assetValue.chain });
+}
+
+export function getVultisigMethods(provider: BrowserProvider, chain: EVMChain) {
+  return {
+    call: async <T>({
+      contractAddress,
+      abi,
+      funcName,
+      funcParams = [],
+      txOverrides,
+    }: CallParams): Promise<T> => {
+      if (!contractAddress) {
+        throw new SwapKitError("wallet_vultisig_contract_address_not_provided");
+      }
+      const { createContract, getCreateContractTxObject, isStateChangingCall } = await import(
+        "@swapkit/toolboxes/evm"
+      );
+
+      const isStateChanging = isStateChangingCall({ abi, funcName });
+
+      if (isStateChanging) {
+        const createTx = getCreateContractTxObject({ provider, chain });
+        const { value, from, to, data } = await createTx({
+          contractAddress,
+          abi,
+          funcName,
+          funcParams,
+          txOverrides,
+        });
+
+        const signer = await provider.getSigner();
+        const tx = await signer.sendTransaction({
+          value: BigInt(value || 0),
+          from,
+          to,
+          data: data || "0x",
+        });
+        return tx.hash as T;
+      }
+      const contract = createContract(contractAddress, abi, provider);
+
+      const result = await contract[funcName]?.(...funcParams);
+
+      return typeof result?.hash === "string" ? result?.hash : result;
+    },
+    approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
+      const { MAX_APPROVAL, getCreateContractTxObject } = await import("@swapkit/toolboxes/evm");
+      const funcParams = [spenderAddress, BigInt(amount || MAX_APPROVAL)];
+      const txOverrides = { from };
+
+      const functionCallParams = {
+        contractAddress: assetAddress,
+        abi: erc20ABI,
+        funcName: "approve",
+        funcParams,
+        txOverrides,
+      };
+
+      const createTx = getCreateContractTxObject({ provider, chain });
+      const { value, to, data } = await createTx(functionCallParams);
+
+      const signer = await provider.getSigner();
+      const tx = await signer.sendTransaction({
+        value: BigInt(value || 0),
+        from,
+        to,
+        data: data || "0x",
+      });
+      return tx.hash;
+    },
+    sendTransaction: async (txParams: EVMTxParams) => {
+      const { from, to, data, value } = txParams;
+      if (!to) {
+        throw new SwapKitError("wallet_vultisig_send_transaction_no_address");
+      }
+
+      const signer = await provider.getSigner();
+      const tx = await signer.sendTransaction({
+        value: BigInt(value || 0),
+        from,
+        to,
+        data: data || "0x",
+      });
+      return tx.hash;
+    },
+  };
+}
+
+export async function switchCosmosWalletNetwork(
+  provider: VultisigCosmosProvider,
+  chain: Chain.Cosmos | Chain.Kujira,
+  networkParams?: NetworkParams,
+) {
+  try {
+    await provider.request({
+      method: "wallet_switch_chain",
+      params: [{ chainId: ChainToChainId[chain] }],
+    });
+  } catch (error) {
+    if (!networkParams) {
+      throw new SwapKitError("helpers_failed_to_switch_network", {
+        error: error,
+        reason: "networkParams not provided",
+      });
+    }
+  }
+}
+
+export function wrapMethodWithNetworkSwitch<T extends (...args: any[]) => any>(
+  func: T,
+  provider: VultisigCosmosProvider,
+  chain: Chain.Cosmos | Chain.Kujira,
+) {
+  return (async (...args: any[]) => {
+    try {
+      await switchCosmosWalletNetwork(provider, chain);
+    } catch (error) {
+      throw new SwapKitError({
+        errorKey: "helpers_failed_to_switch_network",
+        info: { error },
+      });
+    }
+    return func(...args);
+  }) as unknown as T;
+}
+
+export function prepareNetworkSwitchCosmos<
+  T extends Awaited<ReturnType<typeof getCosmosToolbox>>,
+  M extends keyof T,
+>({
+  toolbox,
+  chain,
+  provider = window.ethereum,
+  methodNames = [],
+}: { toolbox: T; chain: Chain; provider?: VultisigCosmosProvider; methodNames?: M[] }) {
+  const methodsToWrap = [...methodNames, "transfer", "getAddress", "getBalance"] as M[];
+  const wrappedMethods = methodsToWrap.reduce((object, methodName) => {
+    if (!toolbox[methodName]) return object;
+
+    const method = toolbox[methodName];
+
+    if (typeof method !== "function") return object;
+
+    // @ts-expect-error
+    const wrappedMethod = wrapMethodWithNetworkSwitch(method, provider, chain);
+
+    // biome-ignore lint/performance/noAccumulatingSpread: valid use case
+    return { ...object, [methodName]: wrappedMethod };
+  }, {});
+
+  return { ...toolbox, ...wrappedMethods };
+}

package/src/walletconnect/constants.ts

@@ -16,6 +16,8 @@ export const BASE_MAINNET_ID = "eip155:8453";
 export const NEAR_MAINNET_ID = "near:mainnet";
 export const NEAR_TESTNET_ID = "near:testnet";
 export const TRON_MAINNET_ID = "tron:0x2b6653dc";
+export const AURORA_MAINNET_ID = "eip155:1313161554";
+export const BERACHAIN_MAINNET_ID = "eip155:80094";
 
 export const DEFAULT_LOGGER = "debug";