@tcswap/wallets 4.3.16

package/src/passkeys/index.ts

@@ -0,0 +1,187 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { Wallet } from "@passkeys/core";
+import {
+  Chain,
+  EVMChains,
+  filterSupportedChains,
+  prepareNetworkSwitch,
+  switchEVMWalletNetwork,
+  USwapConfig,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import type { SolanaProvider } from "@tcswap/toolboxes/solana";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import { Psbt } from "bitcoinjs-lib";
+import {
+  AddressPurpose,
+  BitcoinNetworkType,
+  type GetAddressOptions,
+  type GetAddressResponse,
+  getAddress,
+  type SignTransactionOptions,
+  signTransaction as satsSignTransaction,
+} from "sats-connect";
+import { match } from "ts-pattern";
+
+async function getPasskeyWallet() {
+  const appId = USwapConfig.get("apiKeys").passkeys;
+  const { createWallet } = await import("@passkeys/core");
+
+  return createWallet({
+    appId: appId.length > 0 ? appId : undefined,
+    providers: { bitcoin: true, ethereum: true, solana: true },
+  });
+}
+
+function getWalletMethods({ wallet, chain: paramChain }: { wallet: Wallet; chain: Chain }) {
+  return match(paramChain)
+    .with(Chain.Bitcoin, async (chain) => {
+      const { getUtxoToolbox } = await import("@tcswap/toolboxes/utxo");
+      const provider = await wallet.getProvider("bitcoin");
+
+      if (!provider) {
+        throw new USwapError("wallet_passkeys_not_found");
+      }
+
+      let address = "";
+
+      const getProvider = () => Promise.resolve(provider);
+
+      const getAddressOptions: GetAddressOptions = {
+        getProvider,
+        onCancel: () => {
+          throw new USwapError("wallet_passkeys_request_canceled");
+        },
+        onFinish: (response: GetAddressResponse) => {
+          if (!response.addresses[0]) throw new USwapError("wallet_passkeys_no_address");
+          address = response.addresses[0].address;
+        },
+        payload: {
+          message: "Address for receiving and sending payments",
+          network: { type: BitcoinNetworkType.Mainnet },
+          purposes: [AddressPurpose.Payment],
+        },
+      };
+
+      // TODO: Towan - probably not needed ?
+      await getAddress(getAddressOptions);
+
+      async function signTransaction(psbt: Psbt) {
+        let signedPsbt: Psbt | undefined;
+        const signPsbtOptions: SignTransactionOptions = {
+          getProvider,
+          onCancel: () => {
+            throw new USwapError("wallet_passkeys_signature_canceled");
+          },
+          onFinish: (response) => {
+            signedPsbt = Psbt.fromBase64(response.psbtBase64);
+          },
+          payload: {
+            broadcast: false,
+            inputsToSign: [{ address: address, signingIndexes: psbt.txInputs.map((_, index) => index) }],
+            message: "Sign transaction",
+            network: { type: BitcoinNetworkType.Mainnet },
+            psbtBase64: psbt.toBase64(),
+          },
+        };
+
+        await satsSignTransaction(signPsbtOptions);
+        if (!signedPsbt) throw new USwapError("wallet_passkeys_sign_transaction_error");
+        return signedPsbt;
+      }
+
+      const signer = { getAddress: () => Promise.resolve(address), signTransaction };
+      const toolbox = await getUtxoToolbox(chain, { signer });
+
+      return { ...toolbox, address };
+    })
+    .with(...EVMChains, async (chain) => {
+      const { getProvider, getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+      const { BrowserProvider } = await import("ethers");
+
+      const walletProvider = await wallet.getProvider("ethereum");
+      if (!walletProvider) {
+        throw new USwapError("wallet_passkeys_not_found");
+      }
+
+      const jsonRpcProvider = await getProvider(chain);
+      const browserProvider = new BrowserProvider(walletProvider, "any");
+
+      await browserProvider.send("eth_requestAccounts", []);
+
+      const signer = await browserProvider.getSigner();
+      const address = await signer.getAddress();
+      const toolbox = await getEvmToolbox(chain, { provider: jsonRpcProvider, signer });
+
+      try {
+        if (chain !== Chain.Ethereum) {
+          const networkParams = toolbox.getNetworkParams();
+          await switchEVMWalletNetwork(browserProvider, chain, networkParams);
+        }
+      } catch {
+        throw new USwapError("wallet_passkeys_failed_to_switch_network", { chain });
+      }
+
+      return { ...prepareNetworkSwitch({ chain, provider: browserProvider, toolbox }), address };
+    })
+    .with(Chain.Solana, async () => {
+      const { getSolanaToolbox } = await import("@tcswap/toolboxes/solana");
+      const provider = (await wallet.getProvider("solana")) as any as SolanaProvider;
+      const providerConnection = await provider.connect();
+      const address = providerConnection.publicKey.toString();
+      const toolbox = await getSolanaToolbox({ signer: provider });
+
+      const disconnect = async () => {
+        await provider.disconnect();
+      };
+
+      return { ...toolbox, address, disconnect };
+    })
+    .otherwise((chain) => {
+      throw new USwapError("wallet_passkeys_chain_not_supported", { chain });
+    });
+}
+
+export const passkeysWallet = createWallet({
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectPasskeys(chains: Chain[], paramWallet?: Wallet) {
+      const wallet = paramWallet || (await getPasskeyWallet());
+
+      if (!wallet) throw new USwapError("wallet_passkeys_instance_missing");
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          try {
+            const walletData = await getWalletMethods({ chain, wallet });
+
+            const { address, ...walletMethods } = walletData;
+
+            addChain({
+              ...walletMethods,
+              address,
+              chain,
+              disconnect: wallet.disconnect,
+              walletType: WalletOption.PASSKEYS,
+            });
+          } catch (error) {
+            console.error(`Failed to connect ${chain} wallet:`, error);
+            throw error;
+          }
+        }),
+      );
+
+      return true;
+    },
+  name: "connectPasskeys",
+  supportedChains: [...EVMChains, Chain.Bitcoin, Chain.Solana],
+  walletType: WalletOption.PASSKEYS,
+});
+
+export const PASSKEYS_SUPPORTED_CHAINS = getWalletSupportedChains(passkeysWallet);
+export * from "@passkeys/core";
+export * from "@passkeys/react";

package/src/phantom.ts

@@ -0,0 +1 @@
+export * from "@tcswap/wallet-extensions/phantom";

package/src/polkadotjs.ts

@@ -0,0 +1 @@
+export * from "@tcswap/wallet-extensions/polkadotjs";

package/src/radix/index.ts

@@ -0,0 +1,198 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type {
+  FungibleResourcesCollectionItem,
+  GatewayApiClient,
+  StateEntityDetailsVaultResponseItem,
+  StateEntityFungiblesPageRequest,
+  StateEntityFungiblesPageResponse,
+} from "@radixdlt/babylon-gateway-api-sdk";
+import { AssetValue, Chain, filterSupportedChains, USwapConfig, USwapError, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+
+export const radixWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectRadixWallet(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+      const radixConfig = USwapConfig.get("integrations").radix;
+
+      if (!radixConfig) {
+        throw new USwapError("wallet_radix_not_found");
+      }
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethods();
+
+          addChain({ ...walletMethods, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectRadixWallet",
+  supportedChains: [Chain.Radix],
+  walletType: WalletOption.RADIX_WALLET,
+});
+
+export const RADIX_SUPPORTED_CHAINS = getWalletSupportedChains(radixWallet);
+
+async function fetchFungibleResources(address: string): Promise<FungibleResourcesCollectionItem[]> {
+  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
+  const { applicationName } = USwapConfig.get("integrations").radix;
+  const networkApi = GatewayApiClient.initialize({ applicationName, networkId: 1 });
+
+  let hasNextPage = true;
+  let nextCursor: string | undefined;
+  let fungibleResources: FungibleResourcesCollectionItem[] = [];
+
+  const stateVersion = await currentStateVersion(networkApi);
+
+  while (hasNextPage) {
+    const stateEntityFungiblesPageRequest: StateEntityFungiblesPageRequest = {
+      address: address,
+      at_ledger_state: { state_version: stateVersion },
+      cursor: nextCursor,
+      limit_per_page: 100,
+    };
+
+    const stateEntityFungiblesPageResponse: StateEntityFungiblesPageResponse =
+      await networkApi.state.innerClient.entityFungiblesPage({
+        stateEntityFungiblesPageRequest: stateEntityFungiblesPageRequest,
+      });
+
+    fungibleResources = fungibleResources.concat(stateEntityFungiblesPageResponse.items);
+
+    if (stateEntityFungiblesPageResponse.next_cursor) {
+      nextCursor = stateEntityFungiblesPageResponse.next_cursor;
+    } else {
+      hasNextPage = false;
+    }
+  }
+  return fungibleResources;
+}
+
+function currentStateVersion(networkApi: GatewayApiClient) {
+  return networkApi.status.getCurrent().then((status) => status.ledger_state.state_version);
+}
+
+// TODO - @Towan: is that still needed with USwapApi.getChainBalance()?
+async function getBalance(address: string): Promise<AssetValue[]> {
+  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
+  const resources = await fetchFungibleResources(address);
+  const { applicationName } = USwapConfig.get("integrations").radix;
+  const networkApi = GatewayApiClient.initialize({ applicationName, networkId: 1 });
+
+  const balances: AssetValue[] = [];
+  const BATCH_SIZE = 50;
+
+  // Split resources into batches of up to 50 items
+  const resourceBatches: FungibleResourcesCollectionItem[][] = [];
+  for (let i = 0; i < resources.length; i += BATCH_SIZE) {
+    resourceBatches.push(resources.slice(i, i + BATCH_SIZE));
+  }
+
+  for (const batch of resourceBatches) {
+    const addresses = batch.map((item) => item.resource_address);
+    const response: StateEntityDetailsVaultResponseItem[] =
+      await networkApi.state.getEntityDetailsVaultAggregated(addresses);
+
+    const divisibilities = new Map<string, { decimals: number; symbol: string }>();
+
+    for (const result of response) {
+      if (result.details !== undefined) {
+        const metaDataSymbol = result.metadata?.items.find((item) => item.key === "symbol");
+        const symbol = metaDataSymbol?.value.typed.type === "String" ? metaDataSymbol.value.typed.value : "?";
+
+        if (result.details.type === "FungibleResource") {
+          divisibilities.set(result.address, { decimals: result.details.divisibility, symbol });
+        }
+      }
+    }
+
+    for (const item of batch) {
+      if (item.aggregation_level === "Global") {
+        const assetInfo = divisibilities.get(item.resource_address) || { decimals: 0, symbol: "?" };
+
+        const balance = AssetValue.from({
+          asset:
+            assetInfo.symbol !== Chain.Radix
+              ? `${Chain.Radix}.${assetInfo.symbol}-${item.resource_address}`
+              : "XRD.XRD",
+          value: item.amount,
+        });
+        balances.push(balance);
+      }
+    }
+  }
+
+  const hasNativeAsset = balances.some((asset) => asset.isGasAsset);
+  if (!hasNativeAsset) {
+    return [AssetValue.from({ chain: Chain.Radix }), ...balances];
+  }
+
+  return balances;
+}
+
+async function getWalletMethods() {
+  const { RadixDappToolkit } = await import("@radixdlt/radix-dapp-toolkit");
+  const dappConfig = USwapConfig.get("integrations").radix;
+  const rdt = RadixDappToolkit({ ...dappConfig, networkId: dappConfig.network.networkId });
+
+  function delay(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  // TODO: @Towan - Wat is dat?
+  await delay(400);
+
+  function getAddress() {
+    const existingWalletData = rdt.walletApi.getWalletData();
+    const account = existingWalletData?.accounts?.[0];
+
+    return account?.address;
+  }
+
+  const getNewAddress = async () => {
+    const { DataRequestBuilder } = await import("@radixdlt/radix-dapp-toolkit");
+    rdt.walletApi.setRequestData(DataRequestBuilder.accounts().exactly(1));
+    const res = await rdt.walletApi.sendRequest();
+
+    if (!res) {
+      throw new USwapError("wallet_radix_no_account");
+    }
+
+    const newAddress = res.unwrapOr(null)?.accounts[0]?.address;
+
+    if (!newAddress) {
+      throw new USwapError("wallet_radix_no_account");
+    }
+
+    return newAddress;
+  };
+
+  const address = getAddress() || (await getNewAddress());
+
+  return {
+    address,
+    getAddress,
+    getBalance: () => getBalance(address),
+    radixDappToolkit: rdt,
+    signAndBroadcast: async ({ manifest, message }: { manifest: string; message: string }) => {
+      const tx = await rdt.walletApi.sendTransaction({ message, transactionManifest: manifest });
+
+      const txResult = tx.unwrapOr(null)?.transactionIntentHash;
+
+      if (!txResult) {
+        throw new USwapError("wallet_radix_transaction_failed");
+      }
+
+      return txResult;
+    },
+    transfer: (_params: { assetValue: AssetValue; recipient: string; from: string }) => {
+      throw new USwapError("wallet_radix_method_not_supported", { method: "transfer" });
+    },
+  };
+}

package/src/talisman.ts

@@ -0,0 +1 @@
+export * from "@tcswap/wallet-extensions/talisman";

package/src/trezor.ts

@@ -0,0 +1 @@
+export * from "@tcswap/wallet-hardware/trezor";

package/src/tronlink.ts

@@ -0,0 +1 @@
+export * from "@tcswap/wallet-extensions/tronlink";

package/src/types.ts

@@ -0,0 +1,94 @@
+import { WalletOption } from "@tcswap/helpers";
+import type { bitgetWallet } from "@tcswap/wallet-extensions/bitget";
+import type { cosmostationWallet } from "@tcswap/wallet-extensions/cosmostation";
+import type { ctrlWallet } from "@tcswap/wallet-extensions/ctrl";
+import type { evmWallet } from "@tcswap/wallet-extensions/evm-extensions";
+import type { keepkeyBexWallet } from "@tcswap/wallet-extensions/keepkey-bex";
+import type { keplrWallet } from "@tcswap/wallet-extensions/keplr";
+import type { okxWallet } from "@tcswap/wallet-extensions/okx";
+import type { onekeyWallet } from "@tcswap/wallet-extensions/onekey";
+import type { phantomWallet } from "@tcswap/wallet-extensions/phantom";
+import type { polkadotWallet } from "@tcswap/wallet-extensions/polkadotjs";
+import type { talismanWallet } from "@tcswap/wallet-extensions/talisman";
+import type { tronlinkWallet } from "@tcswap/wallet-extensions/tronlink";
+import type { vultisigWallet } from "@tcswap/wallet-extensions/vultisig";
+import type { keepkeyWallet } from "@tcswap/wallet-hardware/keepkey";
+import type { ledgerWallet } from "@tcswap/wallet-hardware/ledger";
+import type { trezorWallet } from "@tcswap/wallet-hardware/trezor";
+import type { coinbaseWallet } from "./coinbase";
+import type { keystoreWallet } from "./keystore";
+import type { walletSelectorWallet } from "./near-wallet-selector";
+import type { passkeysWallet } from "./passkeys";
+import type { radixWallet } from "./radix";
+import type { walletconnectWallet } from "./walletconnect";
+import type { xamanWallet } from "./xaman";
+
+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 passkeysWallet;
+  [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.PASSKEYS]: typeof passkeysWallet;
+  [WalletOption.PHANTOM]: typeof phantomWallet;
+  [WalletOption.POLKADOT_JS]: typeof polkadotWallet;
+  [WalletOption.RADIX_WALLET]: typeof radixWallet;
+  [WalletOption.TALISMAN]: typeof talismanWallet;
+  [WalletOption.TREZOR]: typeof trezorWallet;
+  [WalletOption.TRONLINK]: typeof tronlinkWallet;
+  [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet;
+  [WalletOption.VULTISIG]: typeof vultisigWallet;
+  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
+  [WalletOption.WALLET_SELECTOR]: typeof walletSelectorWallet;
+  [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 passkeysWallet.connectPasskeys.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.PASSKEYS]: typeof passkeysWallet.connectPasskeys.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.TRONLINK]: typeof tronlinkWallet.connectTronLink.supportedChains;
+  [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.VULTISIG]: typeof vultisigWallet.connectVultisig.supportedChains;
+  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
+  [WalletOption.WALLET_SELECTOR]: typeof walletSelectorWallet.connectWalletSelector.supportedChains;
+  [WalletOption.XAMAN]: typeof xamanWallet.connectXaman.supportedChains;
+};

package/src/utils.ts

@@ -0,0 +1,59 @@
+import { WalletOption } from "@tcswap/helpers";
+import type { SKWallets } from "./types";
+
+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("@tcswap/wallet-extensions/bitget")).bitgetWallet)
+    .with(WalletOption.CTRL, async () => (await import("@tcswap/wallet-extensions/ctrl")).ctrlWallet)
+    .with(WalletOption.VULTISIG, async () => (await import("@tcswap/wallet-extensions/vultisig")).vultisigWallet)
+    .with(WalletOption.OKX, async () => (await import("@tcswap/wallet-extensions/okx")).okxWallet)
+    .with(WalletOption.ONEKEY, async () => (await import("@tcswap/wallet-extensions/onekey")).onekeyWallet)
+    .with(WalletOption.EXODUS, async () => (await import("./passkeys")).passkeysWallet)
+    .with(WalletOption.KEEPKEY, async () => (await import("@tcswap/wallet-hardware/keepkey")).keepkeyWallet)
+    .with(
+      WalletOption.KEEPKEY_BEX,
+      async () => (await import("@tcswap/wallet-extensions/keepkey-bex")).keepkeyBexWallet,
+    )
+    .with(WalletOption.WALLETCONNECT, async () => (await import("./walletconnect")).walletconnectWallet)
+    .with(
+      WalletOption.KEPLR,
+      WalletOption.LEAP,
+      async () => (await import("@tcswap/wallet-extensions/keplr")).keplrWallet,
+    )
+    .with(
+      WalletOption.COSMOSTATION,
+      async () => (await import("@tcswap/wallet-extensions/cosmostation")).cosmostationWallet,
+    )
+    .with(
+      WalletOption.BRAVE,
+      WalletOption.COINBASE_WEB,
+      WalletOption.EIP6963,
+      WalletOption.METAMASK,
+      WalletOption.OKX_MOBILE,
+      WalletOption.TRUSTWALLET_WEB,
+      async () => (await import("@tcswap/wallet-extensions/evm-extensions")).evmWallet,
+    )
+
+    .with(WalletOption.KEYSTORE, async () => (await import("@tcswap/wallet-keystore")).keystoreWallet)
+    .with(WalletOption.TREZOR, async () => (await import("@tcswap/wallet-hardware/trezor")).trezorWallet)
+    .with(
+      WalletOption.LEDGER,
+      // TODO: Remove
+      WalletOption.LEDGER_LIVE,
+      async () => (await import("@tcswap/wallet-hardware/ledger")).ledgerWallet,
+    )
+    .with(WalletOption.PASSKEYS, async () => (await import("./passkeys")).passkeysWallet)
+    .with(WalletOption.PHANTOM, async () => (await import("@tcswap/wallet-extensions/phantom")).phantomWallet)
+    .with(WalletOption.POLKADOT_JS, async () => (await import("@tcswap/wallet-extensions/polkadotjs")).polkadotWallet)
+    .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
+    .with(WalletOption.TALISMAN, async () => (await import("@tcswap/wallet-extensions/talisman")).talismanWallet)
+    .with(WalletOption.TRONLINK, async () => (await import("@tcswap/wallet-extensions/tronlink")).tronlinkWallet)
+    .with(WalletOption.WALLET_SELECTOR, async () => (await import("./near-wallet-selector")).walletSelectorWallet)
+    .with(WalletOption.XAMAN, async () => (await import("./xaman")).xamanWallet)
+    .exhaustive();
+
+  return wallet as SKWallets[W];
+}

package/src/vultisig.ts

@@ -0,0 +1 @@
+export * from "@tcswap/wallet-extensions/vultisig";

package/src/walletconnect/constants.ts

@@ -0,0 +1,109 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { ClientMetadata } from "./types";
+
+export const DEFAULT_RELAY_URL = "wss://relay.walletconnect.com";
+
+export const ETHEREUM_MAINNET_ID = "eip155:1";
+export const BSC_MAINNET_ID = "eip155:56";
+export const AVALANCHE_MAINNET_ID = "eip155:43114";
+export const THORCHAIN_MAINNET_ID = "cosmos:thorchain";
+export const COSMOS_HUB_MAINNET_ID = "cosmos:cosmoshub-4";
+export const KUJIRA_MAINNET_ID = "cosmos:kaiyo-1";
+export const MAYACHAIN_MAINNET_ID = "cosmos:mayachain-mainnet-v1";
+export const ARBITRUM_ONE_MAINNET_ID = "eip155:42161";
+export const OPTIMISM_MAINNET_ID = "eip155:10";
+export const POLYGON_MAINNET_ID = "eip155:137";
+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 MONAD_MAINNET_ID = "eip155:143";
+
+export const DEFAULT_LOGGER = "debug";
+
+export const DEFAULT_APP_METADATA: ClientMetadata = {
+  description: "USwap cross-chain SDK",
+  icons: [
+    "https://raw.githubusercontent.com/horizontalsystems/USwap/refs/heads/develop/docs/src/assets/logo-black.png",
+  ],
+  name: "USwap",
+  url: "https://uswap.dev/",
+};
+
+/**
+ * EIP155
+ */
+export enum DEFAULT_EIP155_METHODS {
+  ETH_SEND_TRANSACTION = "eth_sendTransaction",
+  // not supported by most WC wallets
+  // ETH_SIGN_TRANSACTION = 'eth_signTransaction',
+  ETH_SIGN = "eth_sign",
+  PERSONAL_SIGN = "personal_sign",
+  ETH_SIGN_TYPED_DATA = "eth_signTypedData",
+}
+
+export enum DEFAULT_EIP_155_EVENTS {
+  ETH_CHAIN_CHANGED = "chainChanged",
+  ETH_ACCOUNTS_CHANGED = "accountsChanged",
+}
+
+/**
+ * COSMOS
+ */
+export enum DEFAULT_COSMOS_METHODS {
+  COSMOS_SIGN_DIRECT = "cosmos_signDirect",
+  COSMOS_SIGN_AMINO = "cosmos_signAmino",
+  COSMOS_GET_ACCOUNTS = "cosmos_getAccounts",
+}
+
+export enum DEFAULT_COSMOS_EVENTS {}
+
+/**
+ * SOLANA
+ */
+export enum DEFAULT_SOLANA_METHODS {
+  SOL_SIGN_TRANSACTION = "solana_signTransaction",
+  SOL_SIGN_MESSAGE = "solana_signMessage",
+}
+
+export enum DEFAULT_SOLANA_EVENTS {}
+
+/**
+ * POLKADOT
+ */
+export enum DEFAULT_POLKADOT_METHODS {
+  POLKADOT_SIGN_TRANSACTION = "polkadot_signTransaction",
+  POLKADOT_SIGN_MESSAGE = "polkadot_signMessage",
+}
+
+export enum DEFAULT_POLKADOT_EVENTS {}
+
+/**
+ * NEAR
+ */
+export enum DEFAULT_NEAR_METHODS {
+  NEAR_SIGN_IN = "near_signIn",
+  NEAR_SIGN_OUT = "near_signOut",
+  NEAR_GET_ACCOUNTS = "near_getAccounts",
+  NEAR_SIGN_AND_SEND_TRANSACTION = "near_signAndSendTransaction",
+  NEAR_SIGN_AND_SEND_TRANSACTIONS = "near_signAndSendTransactions",
+}
+
+export enum DEFAULT_NEAR_EVENTS {}
+
+/**
+ * TRON
+ */
+export enum DEFAULT_TRON_METHODS {
+  TRON_SIGN_MESSAGE = "tron_signMessage",
+  TRON_SIGN_TRANSACTION = "tron_signTransaction",
+  TRON_SEND_TRANSACTION = "tron_sendTransaction",
+  TRON_GET_ACCOUNTS = "tron_getAccounts",
+}
+
+export enum DEFAULT_TRON_EVENTS {}