@swapkit/wallets 4.0.0-beta.53 → 4.0.0-beta.55

package/src/types.ts

@@ -1,280 +0,0 @@
-import type {
-  AminoSignResponse,
-  OfflineAminoSigner,
-  StdSignDoc,
-  StdSignature,
-} from "@cosmjs/amino";
-import type { Keplr } from "@keplr-wallet/types";
-import { type EthereumWindowProvider, WalletOption } from "@swapkit/helpers";
-import type { SolanaProvider } from "@swapkit/toolboxes/solana";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-
-import type { SubstrateInjectedExtension } from "@swapkit/toolboxes/substrate";
-import type { bitgetWallet } from "./bitget";
-import type { coinbaseWallet } from "./coinbase";
-import type { cosmostationWallet } from "./cosmostation";
-import type { ctrlWallet } from "./ctrl";
-import type { evmWallet } from "./evm-extensions";
-import type { exodusWallet } from "./exodus";
-import type { NearBrowserWalletProvider } from "./helpers/near";
-import type { keepkeyWallet } from "./keepkey";
-import type { keepkeyBexWallet } from "./keepkey-bex";
-import type { keplrWallet } from "./keplr";
-import type { keystoreWallet } from "./keystore";
-import type { ledgerWallet } from "./ledger";
-import type { okxWallet } from "./okx";
-import type { onekeyWallet } from "./onekey";
-import type { phantomWallet } from "./phantom";
-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;
-  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet;
-  [WalletOption.COINBASE_WEB]: typeof evmWallet;
-  [WalletOption.COSMOSTATION]: typeof cosmostationWallet;
-  [WalletOption.CTRL]: typeof ctrlWallet;
-  [WalletOption.EIP6963]: typeof evmWallet;
-  [WalletOption.EXODUS]: typeof exodusWallet;
-  [WalletOption.KEEPKEY]: typeof keepkeyWallet;
-  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet;
-  [WalletOption.KEPLR]: typeof keplrWallet;
-  [WalletOption.KEYSTORE]: typeof keystoreWallet;
-  [WalletOption.LEAP]: typeof keplrWallet;
-  [WalletOption.LEDGER]: typeof ledgerWallet;
-  [WalletOption.LEDGER_LIVE]: typeof ledgerWallet;
-  [WalletOption.METAMASK]: typeof evmWallet;
-  [WalletOption.OKX]: typeof okxWallet;
-  [WalletOption.OKX_MOBILE]: typeof evmWallet;
-  [WalletOption.ONEKEY]: typeof onekeyWallet;
-  [WalletOption.PHANTOM]: typeof phantomWallet;
-  [WalletOption.POLKADOT_JS]: typeof polkadotWallet;
-  [WalletOption.RADIX_WALLET]: typeof radixWallet;
-  [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;
-};
-
-export type SKConnectWallets = SKWallets[keyof SKWallets];
-
-export type SKWalletsSupportedChains = {
-  [WalletOption.BITGET]: typeof bitgetWallet.connectBitget.supportedChains;
-  [WalletOption.BRAVE]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet.connectCoinbaseWallet.supportedChains;
-  [WalletOption.COINBASE_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.COSMOSTATION]: typeof cosmostationWallet.connectCosmostation.supportedChains;
-  [WalletOption.CTRL]: typeof ctrlWallet.connectCtrl.supportedChains;
-  [WalletOption.EIP6963]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.EXODUS]: typeof exodusWallet.connectExodusWallet.supportedChains;
-  [WalletOption.KEEPKEY]: typeof keepkeyWallet.connectKeepkey.supportedChains;
-  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet.connectKeepkeyBex.supportedChains;
-  [WalletOption.KEPLR]: typeof keplrWallet.connectKeplr.supportedChains;
-  [WalletOption.KEYSTORE]: typeof keystoreWallet.connectKeystore.supportedChains;
-  [WalletOption.LEAP]: typeof keplrWallet.connectKeplr.supportedChains;
-  [WalletOption.LEDGER]: typeof ledgerWallet.connectLedger.supportedChains;
-  [WalletOption.LEDGER_LIVE]: typeof ledgerWallet.connectLedger.supportedChains;
-  [WalletOption.METAMASK]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.OKX]: typeof okxWallet.connectOkx.supportedChains;
-  [WalletOption.OKX_MOBILE]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.ONEKEY]: typeof onekeyWallet.connectOnekeyWallet.supportedChains;
-  [WalletOption.PHANTOM]: typeof phantomWallet.connectPhantom.supportedChains;
-  [WalletOption.POLKADOT_JS]: typeof polkadotWallet.connectPolkadotJs.supportedChains;
-  [WalletOption.RADIX_WALLET]: typeof radixWallet.connectRadixWallet.supportedChains;
-  [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;
-};
-
-type UnisatToSignInputs = {
-  index: number;
-  sighashTypes?: number[];
-  disableTweakSigner?: boolean;
-} & ({ address: string } | { publicKey: string });
-
-declare global {
-  interface Window {
-    injectedWeb3?: SubstrateInjectedExtension;
-    talismanEth?: EthereumWindowProvider;
-    $onekey?: any;
-    braveSolana: any;
-    coinbaseWalletExtension: EthereumWindowProvider;
-    ethereum: EthereumWindowProvider;
-    keplr: Keplr;
-    leap: Keplr;
-    trustwallet: EthereumWindowProvider;
-    phantom: {
-      solana: SolanaProvider;
-    };
-
-    xfi?: {
-      binance: Eip1193Provider;
-      bitcoin: Eip1193Provider;
-      bitcoincash: Eip1193Provider;
-      dogecoin: Eip1193Provider;
-      ethereum: BrowserProvider;
-      keplr: Keplr;
-      litecoin: Eip1193Provider;
-      thorchain: Eip1193Provider;
-      mayachain: Eip1193Provider;
-      solana: SolanaProvider & { isXDEFI: boolean };
-      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[]]>;
-        signMessage: (message: string, type?: "ecdsa" | "bip322-simple") => Promise<string>;
-        signPsbt: (
-          psbtHex: string,
-          {
-            autoFinalized,
-            toSignInputs,
-          }: { autoFinalized?: boolean; toSignInputs?: UnisatToSignInputs[] },
-        ) => Promise<string>;
-      };
-      keplr: {
-        enable: (chainId: string | string[]) => Promise<void>;
-        signAmino: (
-          chainId: string,
-          signer: string,
-          signDoc: StdSignDoc,
-          signOptions: any,
-        ) => Promise<AminoSignResponse>;
-        signArbitrary: (
-          chainId: string,
-          signer: string,
-          data: string | Uint8Array,
-        ) => Promise<StdSignature>;
-        verifyArbitrary: (
-          chainId: string,
-          signer: string,
-          data: string | Uint8Array,
-          signature: StdSignature,
-        ) => Promise<boolean>;
-        getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
-      };
-      solana: SolanaProvider;
-      ethereum: EthereumWindowProvider;
-      tronLink: {
-        request: (args: { method: string; params?: any }) => Promise<any>;
-        ready: boolean;
-      };
-      tronWeb: {
-        defaultAddress: {
-          base58: string;
-          hex: string;
-        };
-        trx: {
-          sign: (transaction: any) => Promise<any>;
-          sendRawTransaction: (signedTransaction: any) => Promise<any>;
-          getAccount: (address: string) => Promise<any>;
-          getBalance: (address: string) => Promise<number>;
-        };
-      };
-    };
-
-    okxwallet?:
-      | {
-          bitcoin: {
-            connect: () => Promise<{
-              address: string;
-              publicKey: string;
-            }>;
-            disconnect: () => Promise<void>;
-            signMessage: (message: string, { from }: { from: string }) => Promise<string>;
-            signPsbt: (
-              psbtHex: string,
-              { from, type }: { from: string; type: string },
-            ) => Promise<string>;
-          };
-          keplr: {
-            enable: (chainId: string | string[]) => Promise<void>;
-            signAmino: (
-              chainId: string,
-              signer: string,
-              signDoc: StdSignDoc,
-              signOptions: any,
-            ) => Promise<AminoSignResponse>;
-            signArbitrary: (
-              chainId: string,
-              signer: string,
-              data: string | Uint8Array,
-            ) => Promise<StdSignature>;
-            verifyArbitrary: (
-              chainId: string,
-              signer: string,
-              data: string | Uint8Array,
-              signature: StdSignature,
-            ) => Promise<boolean>;
-            getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
-          };
-          near: NearBrowserWalletProvider & {
-            requestSignIn: (params?: {
-              contractId?: string;
-              methodNames?: string[];
-            }) => Promise<{ accountId: string; accessKey?: any }>;
-            requestSignTransactions: (params: {
-              transactions: any[];
-            }) => Promise<any>;
-          };
-          tronLink: {
-            request: (args: { method: string; params?: any }) => Promise<any>;
-            ready: boolean;
-            tronWeb: {
-              defaultAddress: {
-                base58: string;
-                hex: string;
-              };
-              trx: {
-                sign: (transaction: any) => Promise<any>;
-                sendRawTransaction: (signedTransaction: any) => Promise<any>;
-                getAccount: (address: string) => Promise<any>;
-                getBalance: (address: string) => Promise<number>;
-              };
-            };
-          };
-        }
-      | EthereumWindowProvider;
-  }
-}

package/src/utils.ts

@@ -1,60 +0,0 @@
-import { WalletOption, type createWallet } from "@swapkit/helpers";
-import type { SKWallets } from "./types";
-
-export function getWalletSupportedChains<
-  T extends ReturnType<typeof createWallet<any, any, any, any>>,
->(wallet: T): T[keyof T]["supportedChains"] {
-  const walletName = Object.keys(wallet)?.[0] || "";
-  return wallet?.[walletName]?.supportedChains || [];
-}
-
-export async function loadWallet<W extends WalletOption>(walletOption: W): Promise<SKWallets[W]> {
-  const { match } = await import("ts-pattern");
-
-  const wallet = await match(walletOption as WalletOption)
-    .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)
-    .with(WalletOption.KEEPKEY, async () => (await import("./keepkey")).keepkeyWallet)
-    .with(WalletOption.KEEPKEY_BEX, async () => (await import("./keepkey-bex")).keepkeyBexWallet)
-    .with(
-      WalletOption.WALLETCONNECT,
-      async () => (await import("./walletconnect")).walletconnectWallet,
-    )
-    .with(WalletOption.KEPLR, WalletOption.LEAP, async () => (await import("./keplr")).keplrWallet)
-    .with(
-      WalletOption.COSMOSTATION,
-      async () => (await import("./cosmostation")).cosmostationWallet,
-    )
-    .with(
-      WalletOption.BRAVE,
-      WalletOption.COINBASE_WEB,
-      WalletOption.EIP6963,
-      WalletOption.METAMASK,
-      WalletOption.OKX_MOBILE,
-      WalletOption.TRUSTWALLET_WEB,
-      async () => (await import("./evm-extensions")).evmWallet,
-    )
-
-    .with(WalletOption.KEYSTORE, async () => (await import("./keystore")).keystoreWallet)
-    .with(WalletOption.TREZOR, async () => (await import("./trezor")).trezorWallet)
-    .with(
-      WalletOption.LEDGER,
-      // TODO: Remove
-      WalletOption.LEDGER_LIVE,
-      async () => (await import("./ledger")).ledgerWallet,
-    )
-
-    .with(WalletOption.PHANTOM, async () => (await import("./phantom")).phantomWallet)
-    .with(WalletOption.POLKADOT_JS, async () => (await import("./polkadotjs")).polkadotWallet)
-    .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
-    .with(WalletOption.TALISMAN, async () => (await import("./talisman")).talismanWallet)
-    .with(WalletOption.XAMAN, async () => (await import("./xaman")).xamanWallet)
-    .exhaustive();
-
-  return wallet as SKWallets[W];
-}

package/src/vultisig/index.ts

@@ -1,199 +0,0 @@
-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);
-}