@sodax/wallet-sdk-react 1.3.1-beta-rc1 → 1.3.1-beta-rc2

package/dist/index.mjs

@@ -1,11 +1,17 @@
-import { baseChainInfo, ChainTypeArr, KAIA_MAINNET_CHAIN_ID, REDBELLY_MAINNET_CHAIN_ID, LIGHTLINK_MAINNET_CHAIN_ID, HYPEREVM_MAINNET_CHAIN_ID, POLYGON_MAINNET_CHAIN_ID, OPTIMISM_MAINNET_CHAIN_ID, SONIC_MAINNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BASE_MAINNET_CHAIN_ID, ARBITRUM_MAINNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, ETHEREUM_MAINNET_CHAIN_ID } from '@sodax/types';
+import { detectBitcoinAddressType, baseChainInfo, ChainTypeArr, KAIA_MAINNET_CHAIN_ID, REDBELLY_MAINNET_CHAIN_ID, LIGHTLINK_MAINNET_CHAIN_ID, HYPEREVM_MAINNET_CHAIN_ID, POLYGON_MAINNET_CHAIN_ID, OPTIMISM_MAINNET_CHAIN_ID, SONIC_MAINNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BASE_MAINNET_CHAIN_ID, ARBITRUM_MAINNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, ETHEREUM_MAINNET_CHAIN_ID } from '@sodax/types';
 import { NearConnector } from '@hot-labs/near-connect';
 import { JsonRpcProvider } from 'near-api-js';
+import { AddressPurpose, MessageSigningProtocols } from 'sats-connect';
+import React2, { useMemo, useCallback, useEffect } from 'react';
+import { useCurrentAccount, useCurrentWallet, useConnectWallet, useWallets, useDisconnectWallet, useSignPersonalMessage, SuiClientProvider, WalletProvider, useSuiClient } from '@mysten/dapp-kit';
+import { useWallet, ConnectionProvider, WalletProvider as WalletProvider$1, useConnection } from '@solana/wallet-adapter-react';
+import { useConnections, useAccount, useConnect, useConnectors, useDisconnect, useSwitchChain, usePublicClient, useWalletClient, useSignMessage, WagmiProvider, createConfig, http, useConfig } from 'wagmi';
+import { create } from 'zustand';
+import { devtools, persist, createJSONStorage } from 'zustand/middleware';
+import { immer } from 'zustand/middleware/immer';
 import { erc20Abi, defineChain } from 'viem';
 import { getPublicClient } from 'wagmi/actions';
-import { useConnections, useAccount, useConnect, useConnectors, useDisconnect, useSwitchChain, usePublicClient, useWalletClient, useSignMessage, WagmiProvider, createConfig, http, useConfig } from 'wagmi';
 import { mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, lightlinkPhoenix, kaia, redbellyMainnet } from 'wagmi/chains';
-import * as IconSdkRaw from 'icon-sdk-js';
 import { getNetworkEndpoints, Network } from '@injectivelabs/networks';
 import { IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi, getInjectiveAddress, getEthereumAddress } from '@injectivelabs/sdk-ts';
 import { ChainId } from '@injectivelabs/ts-types';
@@ -18,12 +24,7 @@ import { getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token';
 import { StellarWalletsKit, allowAllModules, WalletNetwork } from '@creit.tech/stellar-wallets-kit';
 import * as StellarSdk from '@stellar/stellar-sdk';
 import { SorobanRpc, Address, Contract, TimeoutInfinite, scValToBigInt, xdr } from '@stellar/stellar-sdk';
-import React2, { useMemo, useCallback, useEffect } from 'react';
-import { useCurrentAccount, useCurrentWallet, useConnectWallet, useWallets, useDisconnectWallet, useSignPersonalMessage, SuiClientProvider, WalletProvider, useSuiClient } from '@mysten/dapp-kit';
-import { useWallet, ConnectionProvider, WalletProvider as WalletProvider$1, useConnection } from '@solana/wallet-adapter-react';
-import { create } from 'zustand';
-import { devtools, persist, createJSONStorage } from 'zustand/middleware';
-import { immer } from 'zustand/middleware/immer';
+import * as IconSdkRaw from 'icon-sdk-js';
 import { QueryClient, useMutation, useQuery, QueryClientProvider } from '@tanstack/react-query';
 import { mainnet as mainnet$1 } from 'viem/chains';
 import { NearWalletProvider, SolanaWalletProvider, StellarWalletProvider, InjectiveWalletProvider, IconWalletProvider, SuiWalletProvider, EvmWalletProvider } from '@sodax/wallet-sdk-core';
@@ -124,6 +125,8 @@ var NearXService = class _NearXService extends XService {
 // src/actions/getXService.ts
 function getXService(xChainType) {
   switch (xChainType) {
+    case "BITCOIN":
+      return BitcoinXService.getInstance();
     case "EVM":
       return EvmXService.getInstance();
     case "SUI":
@@ -168,14 +171,341 @@ var isNativeToken = (xToken) => {
     "hx0000000000000000000000000000000000000000",
     "11111111111111111111111111111111",
     // solana
-    "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA"
-    // stellar,
+    "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA",
+    // stellar
+    "0:0"
+    // bitcoin
   ];
   return nativeAddresses.includes(xToken.address);
 };
 var getWagmiChainId = (xChainId) => {
   return baseChainInfo[xChainId].chainId;
 };
+
+// src/xchains/bitcoin/BitcoinXService.ts
+var BitcoinXService = class _BitcoinXService extends XService {
+  constructor(rpcUrl = "https://mempool.space/api") {
+    super("BITCOIN");
+    this.rpcUrl = rpcUrl;
+  }
+  static getInstance(rpcUrl) {
+    if (!_BitcoinXService.instance) {
+      _BitcoinXService.instance = new _BitcoinXService(rpcUrl);
+    } else if (rpcUrl && rpcUrl !== _BitcoinXService.instance.rpcUrl) {
+      _BitcoinXService.instance.rpcUrl = rpcUrl;
+    }
+    return _BitcoinXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    try {
+      if (isNativeToken(xToken)) {
+        const response = await fetch(`${this.rpcUrl}/address/${address}/utxo`);
+        if (!response.ok) return 0n;
+        const utxos = await response.json();
+        const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+        return BigInt(totalBalance);
+      }
+    } catch {
+      return 0n;
+    }
+    return 0n;
+  }
+};
+
+// src/xchains/bitcoin/BitcoinXConnector.ts
+var BitcoinXConnector = class extends XConnector {
+  constructor(name, id) {
+    super("BITCOIN", name, id);
+  }
+  getXService() {
+    return BitcoinXService.getInstance();
+  }
+};
+var UnisatWalletProvider = class {
+  constructor(unisat, address) {
+    this.unisat = unisat;
+    this.cachedAddress = address;
+  }
+  async getWalletAddress() {
+    try {
+      const accounts = await this.unisat.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+    }
+    return this.cachedAddress;
+  }
+  async getPublicKey() {
+    return this.unisat.getPublicKey();
+  }
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return detectBitcoinAddressType(address);
+  }
+  async signTransaction(psbtBase64, finalize = false) {
+    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
+    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: finalize });
+    return signedHex;
+  }
+  async signEcdsaMessage(message) {
+    return this.unisat.signMessage(message, "ecdsa");
+  }
+  async signBip322Message(message) {
+    return this.unisat.signMessage(message, "bip322-simple");
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
+  }
+};
+var UnisatXConnector = class extends BitcoinXConnector {
+  constructor() {
+    super("Unisat", "unisat");
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.unisat;
+  }
+  get icon() {
+    return "https://avatars.githubusercontent.com/u/125119198?s=200&v=4";
+  }
+  async connect() {
+    if (!window.unisat) {
+      throw new Error("Unisat wallet is not installed");
+    }
+    const accounts = await window.unisat.requestAccounts();
+    const address = accounts[0];
+    if (!address) return void 0;
+    this.walletProvider = new UnisatWalletProvider(window.unisat, address);
+    return {
+      address,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!window.unisat || !xAccount.address) return void 0;
+    return new UnisatWalletProvider(window.unisat, xAccount.address);
+  }
+};
+var XverseWalletProvider = class {
+  constructor(address, publicKey) {
+    this.address = address;
+    this.publicKey = publicKey;
+  }
+  async getWalletAddress() {
+    return this.address;
+  }
+  async getPublicKey() {
+    return this.publicKey;
+  }
+  async getAddressType(_address) {
+    return detectBitcoinAddressType(this.address);
+  }
+  /**
+   * Parse a base64-encoded PSBT to count the number of inputs.
+   * Reads the unsigned transaction from the PSBT global section.
+   */
+  countPsbtInputs(psbtBase64) {
+    const data = Buffer.from(psbtBase64, "base64");
+    let offset = 5;
+    const keyLen = data[offset++] ?? 0;
+    if (keyLen !== 1 || data[offset++] !== 0) {
+      return 1;
+    }
+    const firstByte = data[offset++] ?? 0;
+    if (firstByte === 253) offset += 2;
+    else if (firstByte === 254) offset += 4;
+    else if (firstByte === 255) offset += 8;
+    offset += 4;
+    const inputByte = data[offset] ?? 0;
+    if (inputByte < 253) return inputByte;
+    return 1;
+  }
+  async signTransaction(psbtBase64, finalize = false) {
+    const { request: request2 } = await import('sats-connect');
+    const inputCount = this.countPsbtInputs(psbtBase64);
+    const signingIndexes = Array.from({ length: inputCount }, (_, i) => i);
+    const response = await request2("signPsbt", {
+      psbt: psbtBase64,
+      broadcast: false,
+      signInputs: {
+        [this.address]: signingIndexes
+      }
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse PSBT signing failed");
+    }
+    const result = response.result;
+    if (finalize) {
+      return Buffer.from(result.psbt, "base64").toString("hex");
+    }
+    return result.psbt;
+  }
+  async signEcdsaMessage(message) {
+    const { request: request2 } = await import('sats-connect');
+    const response = await request2("signMessage", {
+      address: this.address,
+      message,
+      protocol: MessageSigningProtocols.ECDSA
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse ECDSA signing failed");
+    }
+    return response.result.signature;
+  }
+  async signBip322Message(message) {
+    const { request: request2 } = await import('sats-connect');
+    const response = await request2("signMessage", {
+      address: this.address,
+      message,
+      protocol: MessageSigningProtocols.BIP322
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse BIP322 signing failed");
+    }
+    return response.result.signature;
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    const { request: request2 } = await import('sats-connect');
+    const response = await request2("sendTransfer", {
+      recipients: [
+        {
+          address: toAddress,
+          amount: Number(satoshis)
+        }
+      ]
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse sendTransfer failed");
+    }
+    return response.result.txid;
+  }
+};
+var XverseXConnector = class _XverseXConnector extends BitcoinXConnector {
+  constructor() {
+    super("Xverse", "xverse");
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.BitcoinProvider;
+  }
+  get icon() {
+    return "https://cdn.brandfetch.io/iddzGN5Rcv/w/400/h/400/theme/dark/icon.jpeg?c=1bxid64Mup7aczewSAYMX&t=1771902357797";
+  }
+  async connect() {
+    if (!_XverseXConnector.isAvailable()) {
+      throw new Error("Xverse wallet is not installed");
+    }
+    const { request: request2 } = await import('sats-connect');
+    const response = await request2("getAccounts", {
+      purposes: [AddressPurpose.Payment],
+      message: "Connect to Sodax"
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse connection failed");
+    }
+    const accounts = response.result;
+    const paymentAccount = accounts.find((a) => a.purpose === AddressPurpose.Payment) || accounts[0];
+    if (!paymentAccount) return void 0;
+    this.walletProvider = new XverseWalletProvider(
+      paymentAccount.address,
+      paymentAccount.publicKey
+    );
+    return {
+      address: paymentAccount.address,
+      publicKey: paymentAccount.publicKey,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address || !xAccount.publicKey) return void 0;
+    return new XverseWalletProvider(xAccount.address, xAccount.publicKey);
+  }
+};
+var OKXWalletProvider = class {
+  constructor(okx, address) {
+    this.okx = okx;
+    this.cachedAddress = address;
+  }
+  async getWalletAddress() {
+    try {
+      const accounts = await this.okx.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+    }
+    return this.cachedAddress;
+  }
+  async getPublicKey() {
+    return this.okx.getPublicKey();
+  }
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return detectBitcoinAddressType(address);
+  }
+  async signTransaction(psbtBase64, finalize = false) {
+    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
+    return this.okx.signPsbt(psbtHex, { autoFinalized: finalize });
+  }
+  async signEcdsaMessage(message) {
+    return this.okx.signMessage(message, "ecdsa");
+  }
+  async signBip322Message(message) {
+    return this.okx.signMessage(message, "bip322-simple");
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.okx.sendBitcoin(toAddress, Number(satoshis));
+  }
+};
+var OKXXConnector = class extends BitcoinXConnector {
+  constructor() {
+    super("OKX Wallet", "okx-bitcoin");
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.okxwallet?.bitcoin;
+  }
+  get icon() {
+    return "https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png";
+  }
+  async connect() {
+    const okx = window.okxwallet?.bitcoin;
+    if (!okx) {
+      throw new Error("OKX wallet is not installed");
+    }
+    const { address } = await okx.connect();
+    if (!address) return void 0;
+    this.walletProvider = new OKXWalletProvider(okx, address);
+    return {
+      address,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    const okx = window.okxwallet?.bitcoin;
+    if (!okx || !xAccount.address) return void 0;
+    return new OKXWalletProvider(okx, xAccount.address);
+  }
+};
 var hyper = /* @__PURE__ */ defineChain({
   id: 999,
   name: "HyperEVM",
@@ -335,117 +665,6 @@ var EvmXConnector = class extends XConnector {
     return this.connector.icon;
   }
 };
-var IconSdk = "default" in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw;
-var { IconService: IconServiceConstructor, Builder: IconBuilder, Converter: IconConverter } = IconSdk;
-var CHAIN_INFO = {
-  [1 /* MAINNET */]: {
-    APIEndpoint: "https://ctz.solidwallet.io/api/v3"}
-};
-var IconXService = class _IconXService extends XService {
-  constructor() {
-    super("ICON");
-    this.iconService = new IconServiceConstructor(
-      new IconServiceConstructor.HttpProvider(CHAIN_INFO[1 /* MAINNET */].APIEndpoint)
-    );
-  }
-  static getInstance() {
-    if (!_IconXService.instance) {
-      _IconXService.instance = new _IconXService();
-    }
-    return _IconXService.instance;
-  }
-  async getAggregateData(requireSuccess, calls) {
-    const rawTx = new IconBuilder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls }).build();
-    try {
-      const result = await this.iconService.call(rawTx).execute();
-      const aggs = result["returnData"];
-      const data = aggs.map((agg) => {
-        if (agg["success"] === "0x0") {
-          return null;
-        }
-        return agg["returnData"];
-      });
-      return data;
-    } catch (err) {
-      console.error(err);
-      return Array(calls.length).fill(null);
-    }
-  }
-  async getBalances(address, xTokens) {
-    if (!address) return {};
-    const balances = {};
-    const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
-    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
-    if (nativeXToken) {
-      const balance = await this.iconService.getBalance(address).execute();
-      balances[nativeXToken.address] = BigInt(balance.toFixed());
-    }
-    const cds = nonNativeXTokens.map((token) => {
-      return {
-        target: token.address,
-        method: "balanceOf",
-        params: [address]
-      };
-    });
-    const data = await this.getAggregateData(
-      false,
-      cds.filter((cd) => cd.target.startsWith("cx"))
-    );
-    return nonNativeXTokens.reduce((agg, token, idx) => {
-      const balance = data[idx];
-      balances[token.address] = BigInt(balance);
-      return agg;
-    }, balances);
-  }
-};
-
-// src/xchains/icon/iconex/index.tsx
-var ICONEX_RELAY_RESPONSE = "ICONEX_RELAY_RESPONSE";
-var ICONEX_RELAY_REQUEST = "ICONEX_RELAY_REQUEST";
-var request = (event) => {
-  return new Promise((resolve, reject) => {
-    const handler = (evt) => {
-      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
-      resolve(evt.detail);
-    };
-    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
-    window.dispatchEvent(
-      new CustomEvent(ICONEX_RELAY_REQUEST, {
-        detail: event
-      })
-    );
-  });
-};
-
-// src/xchains/icon/IconHanaXConnector.ts
-var IconHanaXConnector = class extends XConnector {
-  constructor() {
-    super("ICON", "Hana Wallet", "hana");
-  }
-  async connect() {
-    const { hanaWallet } = window;
-    if (window && !hanaWallet && !hanaWallet?.isAvailable) {
-      window.open("https://chromewebstore.google.com/detail/hana-wallet/jfdlamikmbghhapbgfoogdffldioobgl", "_blank");
-      return;
-    }
-    const detail = await request({
-      type: "REQUEST_ADDRESS" /* REQUEST_ADDRESS */
-    });
-    if (detail?.type === "RESPONSE_ADDRESS" /* RESPONSE_ADDRESS */) {
-      return {
-        address: detail?.payload,
-        xChainType: this.xChainType
-      };
-    }
-    return void 0;
-  }
-  async disconnect() {
-    console.log("HanaIconXConnector disconnected");
-  }
-  get icon() {
-    return "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg";
-  }
-};
 var InjectiveXService = class _InjectiveXService extends XService {
   constructor() {
     super("INJECTIVE");
@@ -582,25 +801,6 @@ var SolanaXService = class _SolanaXService extends XService {
     }
   }
 };
-
-// src/xchains/solana/SolanaXConnector.ts
-var SolanaXConnector = class extends XConnector {
-  constructor(wallet) {
-    super("SOLANA", wallet?.adapter.name, wallet?.adapter.name);
-    this.wallet = wallet;
-  }
-  getXService() {
-    return SolanaXService.getInstance();
-  }
-  async connect() {
-    return;
-  }
-  async disconnect() {
-  }
-  get icon() {
-    return this.wallet?.adapter.icon;
-  }
-};
 var CustomSorobanServer = class extends SorobanRpc.Server {
   constructor(serverUrl, customHeaders) {
     super(serverUrl, {
@@ -842,9 +1042,122 @@ var SuiXConnector = class extends XConnector {
     return this.wallet?.icon;
   }
 };
+var IconSdk = "default" in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw;
+var { IconService: IconServiceConstructor, Builder: IconBuilder, Converter: IconConverter } = IconSdk;
+var CHAIN_INFO = {
+  [1 /* MAINNET */]: {
+    APIEndpoint: "https://ctz.solidwallet.io/api/v3"}
+};
+var IconXService = class _IconXService extends XService {
+  constructor() {
+    super("ICON");
+    this.iconService = new IconServiceConstructor(
+      new IconServiceConstructor.HttpProvider(CHAIN_INFO[1 /* MAINNET */].APIEndpoint)
+    );
+  }
+  static getInstance() {
+    if (!_IconXService.instance) {
+      _IconXService.instance = new _IconXService();
+    }
+    return _IconXService.instance;
+  }
+  async getAggregateData(requireSuccess, calls) {
+    const rawTx = new IconBuilder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls }).build();
+    try {
+      const result = await this.iconService.call(rawTx).execute();
+      const aggs = result["returnData"];
+      const data = aggs.map((agg) => {
+        if (agg["success"] === "0x0") {
+          return null;
+        }
+        return agg["returnData"];
+      });
+      return data;
+    } catch (err) {
+      console.error(err);
+      return Array(calls.length).fill(null);
+    }
+  }
+  async getBalances(address, xTokens) {
+    if (!address) return {};
+    const balances = {};
+    const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
+    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
+    if (nativeXToken) {
+      const balance = await this.iconService.getBalance(address).execute();
+      balances[nativeXToken.address] = BigInt(balance.toFixed());
+    }
+    const cds = nonNativeXTokens.map((token) => {
+      return {
+        target: token.address,
+        method: "balanceOf",
+        params: [address]
+      };
+    });
+    const data = await this.getAggregateData(
+      false,
+      cds.filter((cd) => cd.target.startsWith("cx"))
+    );
+    return nonNativeXTokens.reduce((agg, token, idx) => {
+      const balance = data[idx];
+      balances[token.address] = BigInt(balance);
+      return agg;
+    }, balances);
+  }
+};
+
+// src/xchains/icon/iconex/index.tsx
+var ICONEX_RELAY_RESPONSE = "ICONEX_RELAY_RESPONSE";
+var ICONEX_RELAY_REQUEST = "ICONEX_RELAY_REQUEST";
+var request = (event) => {
+  return new Promise((resolve, reject) => {
+    const handler = (evt) => {
+      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
+      resolve(evt.detail);
+    };
+    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
+    window.dispatchEvent(
+      new CustomEvent(ICONEX_RELAY_REQUEST, {
+        detail: event
+      })
+    );
+  });
+};
+
+// src/xchains/icon/IconHanaXConnector.ts
+var IconHanaXConnector = class extends XConnector {
+  constructor() {
+    super("ICON", "Hana Wallet", "hana");
+  }
+  async connect() {
+    const { hanaWallet } = window;
+    if (window && !hanaWallet && !hanaWallet?.isAvailable) {
+      window.open("https://chromewebstore.google.com/detail/hana-wallet/jfdlamikmbghhapbgfoogdffldioobgl", "_blank");
+      return;
+    }
+    const detail = await request({
+      type: "REQUEST_ADDRESS" /* REQUEST_ADDRESS */
+    });
+    if (detail?.type === "RESPONSE_ADDRESS" /* RESPONSE_ADDRESS */) {
+      return {
+        address: detail?.payload,
+        xChainType: this.xChainType
+      };
+    }
+    return void 0;
+  }
+  async disconnect() {
+    console.log("HanaIconXConnector disconnected");
+  }
+  get icon() {
+    return "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg";
+  }
+};
+
+// src/useXWagmiStore.ts
 var initXServices = () => {
   const xServices = {};
-  ["EVM", "INJECTIVE", "STELLAR", "SUI", "SOLANA", "ICON", "NEAR"].forEach((key) => {
+  ["EVM", "BITCOIN", "INJECTIVE", "STELLAR", "SUI", "SOLANA", "ICON", "NEAR"].forEach((key) => {
     const xChainType = key;
     switch (xChainType) {
       // EVM, SUI, Solana wallet connectors are supported by their own sdks. wagmi, @mysten/dapp-kit, @solana/wallet-adapter-react.
@@ -860,6 +1173,14 @@ var initXServices = () => {
         xServices[xChainType] = SolanaXService.getInstance();
         xServices[xChainType].setXConnectors([]);
         break;
+      case "BITCOIN":
+        xServices[xChainType] = BitcoinXService.getInstance();
+        xServices[xChainType].setXConnectors([
+          new UnisatXConnector(),
+          new XverseXConnector(),
+          new OKXXConnector()
+        ]);
+        break;
       // Injective, Stellar, Icon wallet connectors are supported by sodax wallet-sdk-react sdk.
       case "INJECTIVE":
         xServices[xChainType] = InjectiveXService.getInstance();
@@ -1072,6 +1393,25 @@ function useXConnect() {
     }
   });
 }
+
+// src/xchains/solana/SolanaXConnector.ts
+var SolanaXConnector = class extends XConnector {
+  constructor(wallet) {
+    super("SOLANA", wallet?.adapter.name, wallet?.adapter.name);
+    this.wallet = wallet;
+  }
+  getXService() {
+    return SolanaXService.getInstance();
+  }
+  async connect() {
+    return;
+  }
+  async disconnect() {
+  }
+  get icon() {
+    return this.wallet?.adapter.icon;
+  }
+};
 var useStellarXConnectors = () => {
   const xService = useXService("STELLAR");
   return useQuery({
@@ -1285,6 +1625,7 @@ function useWalletProvider(spokeChainId) {
   const { data: evmWalletClient } = useWalletClient();
   const xService = useXService(getXChainType(spokeChainId));
   const xAccount = useXAccount(spokeChainId);
+  const xConnection = useXConnection(xChainType);
   return useMemo(() => {
     switch (xChainType) {
       case "EVM": {
@@ -1351,6 +1692,12 @@ function useWalletProvider(spokeChainId) {
           endpoint: solanaXService.connection.rpcEndpoint
         });
       }
+      case "BITCOIN": {
+        if (!xConnection?.xConnectorId) return void 0;
+        const connector = BitcoinXService.getInstance().getXConnectorById(xConnection.xConnectorId);
+        if (!connector) return void 0;
+        return connector.recreateWalletProvider(xConnection.xAccount);
+      }
       case "NEAR": {
         const nearXService = xService;
         if (!nearXService.walletSelector) {
@@ -1361,7 +1708,7 @@ function useWalletProvider(spokeChainId) {
       default:
         return void 0;
     }
-  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
+  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount, xConnection]);
 }
 function useXSignMessage() {
   const { signMessage } = useWallet();
@@ -1417,6 +1764,14 @@ function useXSignMessage() {
     }
   });
 }
+
+// src/xchains/bitcoin/useBitcoinXConnectors.ts
+function useBitcoinXConnectors() {
+  const xService = useXService("BITCOIN");
+  return useMemo(() => {
+    return xService?.getXConnectors() || [];
+  }, [xService]);
+}
 var Hydrate = () => {
   const suiClient = useSuiClient();
   useEffect(() => {
@@ -1523,6 +1878,6 @@ var WalletId = /* @__PURE__ */ ((WalletId2) => {
   return WalletId2;
 })(WalletId || {});
 
-export { EvmXConnector, EvmXService, IconHanaXConnector, IconXService, InjectiveKelprXConnector, InjectiveMetamaskXConnector, InjectiveXService, SodaxWalletProvider, SolanaXConnector, SolanaXService, StellarWalletsKitXConnector, StellarXService, SuiXConnector, SuiXService, WalletId, XConnector, XService, getWagmiChainId, getXChainType, getXService, isNativeToken, switchEthereumChain, useEvmSwitchChain, useWalletProvider, useXAccount, useXAccounts, useXBalances, useXConnect, useXConnection, useXConnectors, useXDisconnect, useXService, useXSignMessage, useXWagmiStore };
+export { BitcoinXConnector, BitcoinXService, EvmXConnector, EvmXService, IconHanaXConnector, IconXService, InjectiveKelprXConnector, InjectiveMetamaskXConnector, InjectiveXService, OKXXConnector, SodaxWalletProvider, SolanaXConnector, SolanaXService, StellarWalletsKitXConnector, StellarXService, SuiXConnector, SuiXService, UnisatXConnector, WalletId, XConnector, XService, XverseXConnector, getWagmiChainId, getXChainType, getXService, isNativeToken, switchEthereumChain, useBitcoinXConnectors, useEvmSwitchChain, useWalletProvider, useXAccount, useXAccounts, useXBalances, useXConnect, useXConnection, useXConnectors, useXDisconnect, useXService, useXSignMessage, useXWagmiStore };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map