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

package/src/ledger/index.ts

@@ -191,7 +191,10 @@ async function getWalletMethods({
     case Chain.THORChain: {
       const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
       const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
-      const { encodePubkey, makeAuthInfoBytes } = (await import("@cosmjs/proto-signing")).default;
+      const importedSigning = await import("@cosmjs/proto-signing");
+      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
+      const makeAuthInfoBytes =
+        importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
       const {
         createStargateClient,
         buildEncodedTxBody,

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/index.ts

@@ -132,8 +132,14 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
     case Chain.THORChain: {
       const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
       const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
-      const { encodePubkey, makeAuthInfoBytes } = (await import("@cosmjs/proto-signing")).default;
-      const { makeSignDoc } = (await import("@cosmjs/amino")).default;
+
+      const importedSigning = await import("@cosmjs/proto-signing");
+      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
+      const makeAuthInfoBytes =
+        importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
+      const importedAmino = await import("@cosmjs/amino");
+      const makeSignDoc = importedAmino.makeSignDoc ?? importedSigning.default?.makeSignDoc;
+
       const {
         getCosmosToolbox,
         buildAminoMsg,

package/dist/chunk-f0qkch7f.js

@@ -1,4 +0,0 @@
-var s={};l(s,{loadWallet:()=>n,getWalletSupportedChains:()=>o});var t=require("@swapkit/helpers");function o(e){let i=Object.keys(e)?.[0]||"";return e?.[i]?.supportedChains||[]}async function n(e){let{match:i}=await import("ts-pattern");return await i(e).with(t.WalletOption.COINBASE_MOBILE,async()=>(await import("./src/coinbase/index.cjs")).coinbaseWallet).with(t.WalletOption.BITGET,async()=>(await import("./src/bitget/index.cjs")).bitgetWallet).with(t.WalletOption.CTRL,async()=>(await import("./src/ctrl/index.cjs")).ctrlWallet).with(t.WalletOption.OKX,async()=>(await import("./src/okx/index.cjs")).okxWallet).with(t.WalletOption.ONEKEY,async()=>(await import("./src/onekey/index.cjs")).onekeyWallet).with(t.WalletOption.EXODUS,async()=>(await import("./src/exodus/index.cjs")).exodusWallet).with(t.WalletOption.KEEPKEY,async()=>(await import("./src/keepkey/index.cjs")).keepkeyWallet).with(t.WalletOption.KEEPKEY_BEX,async()=>(await import("./src/keepkey-bex/index.cjs")).keepkeyBexWallet).with(t.WalletOption.WALLETCONNECT,async()=>(await import("./src/walletconnect/index.cjs")).walletconnectWallet).with(t.WalletOption.KEPLR,t.WalletOption.LEAP,async()=>(await import("./src/keplr/index.cjs")).keplrWallet).with(t.WalletOption.COSMOSTATION,async()=>(await import("./src/cosmostation/index.cjs")).cosmostationWallet).with(t.WalletOption.BRAVE,t.WalletOption.COINBASE_WEB,t.WalletOption.EIP6963,t.WalletOption.METAMASK,t.WalletOption.OKX_MOBILE,t.WalletOption.TRUSTWALLET_WEB,async()=>(await import("./src/evm-extensions/index.cjs")).evmWallet).with(t.WalletOption.KEYSTORE,async()=>(await import("./src/keystore/index.cjs")).keystoreWallet).with(t.WalletOption.TREZOR,async()=>(await import("./src/trezor/index.cjs")).trezorWallet).with(t.WalletOption.LEDGER,t.WalletOption.LEDGER_LIVE,async()=>(await import("./src/ledger/index.cjs")).ledgerWallet).with(t.WalletOption.PHANTOM,async()=>(await import("./src/phantom/index.cjs")).phantomWallet).with(t.WalletOption.POLKADOT_JS,async()=>(await import("./src/polkadotjs/index.cjs")).polkadotWallet).with(t.WalletOption.RADIX_WALLET,async()=>(await import("./src/radix/index.cjs")).radixWallet).with(t.WalletOption.TALISMAN,async()=>(await import("./src/talisman/index.cjs")).talismanWallet).with(t.WalletOption.XAMAN,async()=>(await import("./src/xaman/index.cjs")).xamanWallet).exhaustive()}
-
-//# debugId=14000E57951949B364756E2164756E21
-//# sourceMappingURL=chunk-f0qkch7f.js.map

package/dist/chunk-f0qkch7f.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/utils.ts"],
-  "sourcesContent": [
-    "import { WalletOption, type createWallet } from \"@swapkit/helpers\";\nimport type { SKWallets } from \"./types\";\n\nexport function getWalletSupportedChains<\n  T extends ReturnType<typeof createWallet<any, any, any, any>>,\n>(wallet: T): T[keyof T][\"supportedChains\"] {\n  const walletName = Object.keys(wallet)?.[0] || \"\";\n  return wallet?.[walletName]?.supportedChains || [];\n}\n\nexport async function loadWallet<W extends WalletOption>(walletOption: W): Promise<SKWallets[W]> {\n  const { match } = await import(\"ts-pattern\");\n\n  const wallet = await match(walletOption as WalletOption)\n    .with(WalletOption.COINBASE_MOBILE, async () => (await import(\"./coinbase\")).coinbaseWallet)\n    .with(WalletOption.BITGET, async () => (await import(\"./bitget\")).bitgetWallet)\n    .with(WalletOption.CTRL, async () => (await import(\"./ctrl\")).ctrlWallet)\n    .with(WalletOption.OKX, async () => (await import(\"./okx\")).okxWallet)\n    .with(WalletOption.ONEKEY, async () => (await import(\"./onekey\")).onekeyWallet)\n    .with(WalletOption.EXODUS, async () => (await import(\"./exodus\")).exodusWallet)\n    .with(WalletOption.KEEPKEY, async () => (await import(\"./keepkey\")).keepkeyWallet)\n    .with(WalletOption.KEEPKEY_BEX, async () => (await import(\"./keepkey-bex\")).keepkeyBexWallet)\n    .with(\n      WalletOption.WALLETCONNECT,\n      async () => (await import(\"./walletconnect\")).walletconnectWallet,\n    )\n    .with(WalletOption.KEPLR, WalletOption.LEAP, async () => (await import(\"./keplr\")).keplrWallet)\n    .with(\n      WalletOption.COSMOSTATION,\n      async () => (await import(\"./cosmostation\")).cosmostationWallet,\n    )\n    .with(\n      WalletOption.BRAVE,\n      WalletOption.COINBASE_WEB,\n      WalletOption.EIP6963,\n      WalletOption.METAMASK,\n      WalletOption.OKX_MOBILE,\n      WalletOption.TRUSTWALLET_WEB,\n      async () => (await import(\"./evm-extensions\")).evmWallet,\n    )\n\n    .with(WalletOption.KEYSTORE, async () => (await import(\"./keystore\")).keystoreWallet)\n    .with(WalletOption.TREZOR, async () => (await import(\"./trezor\")).trezorWallet)\n    .with(\n      WalletOption.LEDGER,\n      // TODO: Remove\n      WalletOption.LEDGER_LIVE,\n      async () => (await import(\"./ledger\")).ledgerWallet,\n    )\n\n    .with(WalletOption.PHANTOM, async () => (await import(\"./phantom\")).phantomWallet)\n    .with(WalletOption.POLKADOT_JS, async () => (await import(\"./polkadotjs\")).polkadotWallet)\n    .with(WalletOption.RADIX_WALLET, async () => (await import(\"./radix\")).radixWallet)\n    .with(WalletOption.TALISMAN, async () => (await import(\"./talisman\")).talismanWallet)\n    .with(WalletOption.XAMAN, async () => (await import(\"./xaman\")).xamanWallet)\n    .exhaustive();\n\n  return wallet as SKWallets[W];\n}\n"
-  ],
-  "mappings": "gEAAgD,IAAhD,8BAGO,SAAS,CAEf,CAAC,EAA0C,CAC1C,IAAM,EAAa,OAAO,KAAK,CAAM,IAAI,IAAM,GAC/C,OAAO,IAAS,IAAa,iBAAmB,CAAC,EAGnD,eAAsB,CAAkC,CAAC,EAAwC,CAC/F,IAAQ,SAAU,KAAa,sBA8C/B,OA5Ce,MAAM,EAAM,CAA4B,EACpD,KAAK,eAAa,gBAAiB,UAAa,KAAa,qCAAe,cAAc,EAC1F,KAAK,eAAa,OAAQ,UAAa,KAAa,mCAAa,YAAY,EAC7E,KAAK,eAAa,KAAM,UAAa,KAAa,iCAAW,UAAU,EACvE,KAAK,eAAa,IAAK,UAAa,KAAa,gCAAU,SAAS,EACpE,KAAK,eAAa,OAAQ,UAAa,KAAa,mCAAa,YAAY,EAC7E,KAAK,eAAa,OAAQ,UAAa,KAAa,mCAAa,YAAY,EAC7E,KAAK,eAAa,QAAS,UAAa,KAAa,oCAAc,aAAa,EAChF,KAAK,eAAa,YAAa,UAAa,KAAa,wCAAkB,gBAAgB,EAC3F,KACC,eAAa,cACb,UAAa,KAAa,0CAAoB,mBAChD,EACC,KAAK,eAAa,MAAO,eAAa,KAAM,UAAa,KAAa,kCAAY,WAAW,EAC7F,KACC,eAAa,aACb,UAAa,KAAa,yCAAmB,kBAC/C,EACC,KACC,eAAa,MACb,eAAa,aACb,eAAa,QACb,eAAa,SACb,eAAa,WACb,eAAa,gBACb,UAAa,KAAa,2CAAqB,SACjD,EAEC,KAAK,eAAa,SAAU,UAAa,KAAa,qCAAe,cAAc,EACnF,KAAK,eAAa,OAAQ,UAAa,KAAa,mCAAa,YAAY,EAC7E,KACC,eAAa,OAEb,eAAa,YACb,UAAa,KAAa,mCAAa,YACzC,EAEC,KAAK,eAAa,QAAS,UAAa,KAAa,oCAAc,aAAa,EAChF,KAAK,eAAa,YAAa,UAAa,KAAa,uCAAiB,cAAc,EACxF,KAAK,eAAa,aAAc,UAAa,KAAa,kCAAY,WAAW,EACjF,KAAK,eAAa,SAAU,UAAa,KAAa,qCAAe,cAAc,EACnF,KAAK,eAAa,MAAO,UAAa,KAAa,kCAAY,WAAW,EAC1E,WAAW",
-  "debugId": "14000E57951949B364756E2164756E21",
-  "names": []
-}