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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/wallet-sdk-react",
   "license": "MIT",
-  "version": "1.3.1-beta-rc1",
+  "version": "1.3.1-beta-rc2",
   "description": "Wallet SDK of Sodax",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -43,12 +43,13 @@
     "@stellar/stellar-sdk": "12.3.0",
     "icon-sdk-js": "1.5.3",
     "immer": "10.1.1",
+    "sats-connect": "^4.2.1",
     "viem": "2.29.2",
     "wagmi": "2.16.9",
     "zustand": "4.5.2",
     "bs58": "6.0.0",
-    "@sodax/types": "1.3.1-beta-rc1",
-    "@sodax/wallet-sdk-core": "1.3.1-beta-rc1"
+    "@sodax/wallet-sdk-core": "1.3.1-beta-rc2",
+    "@sodax/types": "1.3.1-beta-rc2"
   },
   "devDependencies": {
     "@types/react": "^19.0.8",

package/src/actions/getXService.ts

@@ -1,6 +1,6 @@
 import type { ChainType } from '@sodax/types';
 
-import { IconXService, InjectiveXService, SolanaXService, StellarXService } from '..';
+import { BitcoinXService, IconXService, InjectiveXService, SolanaXService, StellarXService } from '..';
 import { SuiXService } from '..';
 import { EvmXService } from '..';
 import type { XService } from '../core';
@@ -8,6 +8,8 @@ import { NearXService } from '../xchains/near/NearXService';
 
 export function getXService(xChainType: ChainType): XService {
   switch (xChainType) {
+    case 'BITCOIN':
+      return BitcoinXService.getInstance();
     case 'EVM':
       return EvmXService.getInstance();
     case 'SUI':

package/src/hooks/useWalletProvider.ts

@@ -7,8 +7,11 @@ import type {
   ISolanaWalletProvider,
   IStellarWalletProvider,
   ISuiWalletProvider,
+  IBitcoinWalletProvider,
 } from '@sodax/types';
 import { useMemo } from 'react';
+import { BitcoinXService } from '../xchains/bitcoin/BitcoinXService';
+import type { BitcoinXConnector } from '../xchains/bitcoin/BitcoinXConnector';
 import {
   EvmWalletProvider,
   IconWalletProvider,
@@ -20,7 +23,7 @@ import {
 } from '@sodax/wallet-sdk-core';
 import { getXChainType } from '../actions';
 import { usePublicClient, useWalletClient } from 'wagmi';
-import { type SolanaXService, type StellarXService, useXAccount, useXService } from '..';
+import { type SolanaXService, type StellarXService, useXAccount, useXService, useXConnection } from '..';
 import type { SuiXService } from '../xchains/sui/SuiXService';
 import { CHAIN_INFO, SupportedChainId } from '../xchains/icon/IconXService';
 import type { InjectiveXService } from '../xchains/injective/InjectiveXService';
@@ -52,6 +55,7 @@ export function useWalletProvider(
   | IInjectiveWalletProvider
   | IStellarWalletProvider
   | ISolanaWalletProvider
+  | IBitcoinWalletProvider
   | INearWalletProvider
   | undefined {
   const xChainType = getXChainType(spokeChainId);
@@ -63,6 +67,7 @@ export function useWalletProvider(
   // Cross-chain hooks
   const xService = useXService(getXChainType(spokeChainId));
   const xAccount = useXAccount(spokeChainId);
+  const xConnection = useXConnection(xChainType);
 
   return useMemo(() => {
     switch (xChainType) {
@@ -145,6 +150,13 @@ export function useWalletProvider(
         });
       }
 
+      case 'BITCOIN': {
+        if (!xConnection?.xConnectorId) return undefined;
+        const connector = BitcoinXService.getInstance().getXConnectorById(xConnection.xConnectorId) as BitcoinXConnector | undefined;
+        if (!connector) return undefined;
+        // Recreate from window extension object — works after page reload without reconnect
+        return connector.recreateWalletProvider(xConnection.xAccount);
+      }
       case 'NEAR': {
         const nearXService = xService as NearXService;
         if (!nearXService.walletSelector) {
@@ -157,5 +169,5 @@ export function useWalletProvider(
       default:
         return undefined;
     }
-  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
+  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount, xConnection]);
 }

package/src/index.ts

@@ -3,6 +3,7 @@ export * from './core';
 
 export * from './utils';
 
+export * from './xchains/bitcoin';
 export * from './xchains/evm';
 export * from './xchains/icon';
 export * from './xchains/injective';

package/src/types/index.ts

@@ -3,6 +3,7 @@ import type { ChainType } from '@sodax/types';
 export type XAccount = {
   address: string | undefined;
   xChainType: ChainType | undefined;
+  publicKey?: string;
 };
 
 export type XConnection = {

package/src/useXWagmiStore.ts

@@ -13,6 +13,10 @@ import { StellarXService } from './xchains/stellar';
 import { SuiXService } from './xchains/sui';
 import { IconXService } from './xchains/icon';
 import { IconHanaXConnector } from './xchains/icon/IconHanaXConnector';
+import { BitcoinXService } from './xchains/bitcoin';
+import { UnisatXConnector } from './xchains/bitcoin/UnisatXConnector';
+import { XverseXConnector } from './xchains/bitcoin/XverseXConnector';
+import { OKXXConnector } from './xchains/bitcoin/OKXXConnector';
 import { NearXService } from './xchains/near/NearXService';
 
 type XWagmiStore = {
@@ -25,7 +29,7 @@ type XWagmiStore = {
 
 const 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 as ChainType;
 
     switch (xChainType) {
@@ -42,6 +46,14 @@ const 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':

package/src/utils/index.ts

@@ -8,7 +8,8 @@ export const isNativeToken = (xToken: XToken) => {
     '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI',
     'hx0000000000000000000000000000000000000000',
     '11111111111111111111111111111111', // solana
-    'CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA', // stellar,
+    'CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA', // stellar
+    '0:0', // bitcoin
   ];
 
   return nativeAddresses.includes(xToken.address);

package/src/xchains/bitcoin/BitcoinXConnector.ts

@@ -0,0 +1,34 @@
+import { XConnector } from '@/core';
+import type { XAccount } from '@/types';
+import type { IBitcoinWalletProvider } from '@sodax/types';
+import { BitcoinXService } from './BitcoinXService';
+
+/**
+ * Abstract base class for Bitcoin wallet connectors.
+ * Subclasses implement wallet-specific connection logic (Unisat, Xverse, OKX).
+ */
+export abstract class BitcoinXConnector extends XConnector {
+  constructor(name: string, id: string) {
+    super('BITCOIN', name, id);
+  }
+
+  getXService(): BitcoinXService {
+    return BitcoinXService.getInstance();
+  }
+
+  abstract connect(): Promise<XAccount | undefined>;
+  abstract disconnect(): Promise<void>;
+
+  /**
+   * Returns an IBitcoinWalletProvider instance after connecting.
+   * Used by useSpokeProvider to build BitcoinSpokeProvider.
+   */
+  abstract getWalletProvider(): IBitcoinWalletProvider | undefined;
+
+  /**
+   * Recreates a walletProvider from the browser extension window object
+   * and stored xAccount data (no connect() call, no popup).
+   * Used to restore provider after page reload without requiring reconnect.
+   */
+  abstract recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
+}

package/src/xchains/bitcoin/BitcoinXService.ts

@@ -0,0 +1,40 @@
+import { XService } from '@/core/XService';
+import { isNativeToken } from '@/utils';
+import type { XToken } from '@sodax/types';
+
+export class BitcoinXService extends XService {
+  private static instance: BitcoinXService;
+  private rpcUrl: string;
+
+  private constructor(rpcUrl = 'https://mempool.space/api') {
+    super('BITCOIN');
+    this.rpcUrl = rpcUrl;
+  }
+
+  public static getInstance(rpcUrl?: string): BitcoinXService {
+    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: string | undefined, xToken: XToken): Promise<bigint> {
+    if (!address) return 0n;
+
+    try {
+      if (isNativeToken(xToken)) {
+        const response = await fetch(`${this.rpcUrl}/address/${address}/utxo`);
+        if (!response.ok) return 0n;
+        const utxos: Array<{ value: number }> = await response.json();
+        const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+        return BigInt(totalBalance);
+      }
+    } catch {
+      return 0n;
+    }
+
+    return 0n;
+  }
+}

package/src/xchains/bitcoin/OKXXConnector.ts

@@ -0,0 +1,117 @@
+import type { XAccount } from '@/types';
+import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType } from '@sodax/types';
+import { BitcoinXConnector } from './BitcoinXConnector';
+
+// OKX Bitcoin wallet window API types
+interface OKXBitcoinWallet {
+  getAccounts(): Promise<string[]>;
+  getPublicKey(): Promise<string>;
+  signPsbt(psbtHex: string, options?: { autoFinalized?: boolean }): Promise<string>;
+  signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
+  connect(): Promise<{ address: string; publicKey: string }>;
+  sendBitcoin(toAddress: string, satoshis: number): Promise<string>;
+}
+
+declare global {
+  interface Window {
+    okxwallet?: {
+      bitcoin?: OKXBitcoinWallet;
+    };
+  }
+}
+
+class OKXWalletProvider implements IBitcoinWalletProvider {
+  private okx: OKXBitcoinWallet;
+  private cachedAddress: string;
+
+  constructor(okx: OKXBitcoinWallet, address: string) {
+    this.okx = okx;
+    this.cachedAddress = address;
+  }
+
+  async getWalletAddress(): Promise<string> {
+    try {
+      const accounts = await this.okx.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+      // wallet locked — fall through to cached address
+    }
+    return this.cachedAddress;
+  }
+
+  async getPublicKey(): Promise<string> {
+    return this.okx.getPublicKey();
+  }
+
+  async getAddressType(_address: string): Promise<AddressType> {
+    const address = await this.getWalletAddress();
+    return detectBitcoinAddressType(address);
+  }
+
+  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
+    const psbtHex = Buffer.from(psbtBase64, 'base64').toString('hex');
+    return this.okx.signPsbt(psbtHex, { autoFinalized: finalize });
+  }
+
+  async signEcdsaMessage(message: string): Promise<string> {
+    return this.okx.signMessage(message, 'ecdsa');
+  }
+
+  async signBip322Message(message: string): Promise<string> {
+    return this.okx.signMessage(message, 'bip322-simple');
+  }
+
+  async sendBitcoin(toAddress: string, satoshis: bigint): Promise<string> {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.okx.sendBitcoin(toAddress, Number(satoshis));
+  }
+}
+
+export class OKXXConnector extends BitcoinXConnector {
+  private walletProvider: OKXWalletProvider | undefined;
+
+  constructor() {
+    super('OKX Wallet', 'okx-bitcoin');
+  }
+
+  public static isAvailable(): boolean {
+    return typeof window !== 'undefined' && !!window.okxwallet?.bitcoin;
+  }
+
+  public get icon(): string {
+    return 'https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png';
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    const okx = window.okxwallet?.bitcoin;
+    if (!okx) {
+      throw new Error('OKX wallet is not installed');
+    }
+
+    const { address } = await okx.connect();
+    if (!address) return undefined;
+
+    this.walletProvider = new OKXWalletProvider(okx, address);
+
+    return {
+      address,
+      xChainType: 'BITCOIN',
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    this.walletProvider = undefined;
+  }
+
+  getWalletProvider(): IBitcoinWalletProvider | undefined {
+    return this.walletProvider;
+  }
+
+  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
+    const okx = window.okxwallet?.bitcoin;
+    if (!okx || !xAccount.address) return undefined;
+    return new OKXWalletProvider(okx, xAccount.address);
+  }
+}

package/src/xchains/bitcoin/UnisatXConnector.ts

@@ -0,0 +1,117 @@
+import type { XAccount } from '@/types';
+import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType } from '@sodax/types';
+import { BitcoinXConnector } from './BitcoinXConnector';
+
+// Minimal Unisat window API types
+interface UnisatWallet {
+  getAccounts(): Promise<string[]>;
+  getPublicKey(): Promise<string>;
+  signPsbt(psbtHex: string, options?: { autoFinalized?: boolean }): Promise<string>;
+  signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
+  requestAccounts(): Promise<string[]>;
+  sendBitcoin(address: string, satoshis: number): Promise<string>;
+}
+
+declare global {
+  interface Window {
+    unisat?: UnisatWallet;
+  }
+}
+
+class UnisatWalletProvider implements IBitcoinWalletProvider {
+  private unisat: UnisatWallet;
+  private cachedAddress: string;
+
+  constructor(unisat: UnisatWallet, address: string) {
+    this.unisat = unisat;
+    this.cachedAddress = address;
+  }
+
+  async getWalletAddress(): Promise<string> {
+    try {
+      const accounts = await this.unisat.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+      // wallet locked — fall through to cached address
+    }
+    return this.cachedAddress;
+  }
+
+  async getPublicKey(): Promise<string> {
+    return this.unisat.getPublicKey();
+  }
+
+  async getAddressType(_address: string): Promise<AddressType> {
+    const address = await this.getWalletAddress();
+    return detectBitcoinAddressType(address);
+  }
+
+  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
+    // Convert base64 → hex for Unisat, then back
+    const psbtHex = Buffer.from(psbtBase64, 'base64').toString('hex');
+    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: finalize });
+    // Return as hex (BTCWalletProvider.signTransaction expects this)
+    return signedHex;
+  }
+
+  async signEcdsaMessage(message: string): Promise<string> {
+    return this.unisat.signMessage(message, 'ecdsa');
+  }
+
+  async signBip322Message(message: string): Promise<string> {
+    return this.unisat.signMessage(message, 'bip322-simple');
+  }
+
+  async sendBitcoin(toAddress: string, satoshis: bigint): Promise<string> {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
+  }
+}
+
+export class UnisatXConnector extends BitcoinXConnector {
+  private walletProvider: UnisatWalletProvider | undefined;
+
+  constructor() {
+    super('Unisat', 'unisat');
+  }
+
+  public static isAvailable(): boolean {
+    return typeof window !== 'undefined' && !!window.unisat;
+  }
+
+  public get icon(): string {
+    return 'https://avatars.githubusercontent.com/u/125119198?s=200&v=4';
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    if (!window.unisat) {
+      throw new Error('Unisat wallet is not installed');
+    }
+
+    const accounts = await window.unisat.requestAccounts();
+    const address = accounts[0];
+    if (!address) return undefined;
+
+    this.walletProvider = new UnisatWalletProvider(window.unisat, address);
+
+    return {
+      address,
+      xChainType: 'BITCOIN',
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    this.walletProvider = undefined;
+  }
+
+  getWalletProvider(): IBitcoinWalletProvider | undefined {
+    return this.walletProvider;
+  }
+
+  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
+    if (!window.unisat || !xAccount.address) return undefined;
+    return new UnisatWalletProvider(window.unisat, xAccount.address);
+  }
+}

package/src/xchains/bitcoin/XverseXConnector.ts

@@ -0,0 +1,216 @@
+import type { XAccount } from '@/types';
+import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType } from '@sodax/types';
+import { AddressPurpose, MessageSigningProtocols } from 'sats-connect';
+import { BitcoinXConnector } from './BitcoinXConnector';
+
+// sats-connect types
+interface SignPsbtResult {
+  psbt: string; // base64 signed PSBT
+}
+
+interface GetAccountsResult {
+  address: string;
+  publicKey: string;
+  purpose: string;
+  addressType: string;
+}
+
+interface SignMessageResult {
+  signature: string;
+}
+
+
+class XverseWalletProvider implements IBitcoinWalletProvider {
+  private address: string;
+  private publicKey: string;
+
+  constructor(address: string, publicKey: string) {
+    this.address = address;
+    this.publicKey = publicKey;
+  }
+
+  async getWalletAddress(): Promise<string> {
+    return this.address;
+  }
+
+  async getPublicKey(): Promise<string> {
+    return this.publicKey;
+  }
+
+  async getAddressType(_address: string): Promise<AddressType> {
+    return detectBitcoinAddressType(this.address);
+  }
+
+  /**
+   * Parse a base64-encoded PSBT to count the number of inputs.
+   * Reads the unsigned transaction from the PSBT global section.
+   */
+  private countPsbtInputs(psbtBase64: string): number {
+    const data = Buffer.from(psbtBase64, 'base64');
+    // Skip 5-byte magic (0x70736274FF = "psbt" + separator)
+    let offset = 5;
+
+    // Global section: first key-value pair should be key 0x00 (unsigned tx)
+    const keyLen = data[offset++] ?? 0;
+    if (keyLen !== 1 || data[offset++] !== 0x00) {
+      return 1; // fallback: assume 1 input
+    }
+
+    // Read value length (compact size)
+    const firstByte = data[offset++] ?? 0;
+    if (firstByte === 0xfd) offset += 2;
+    else if (firstByte === 0xfe) offset += 4;
+    else if (firstByte === 0xff) offset += 8;
+    // else firstByte IS the length (< 0xfd), no extra bytes
+
+    // Unsigned tx: skip 4-byte version
+    offset += 4;
+
+    // Read input count (varint)
+    const inputByte = data[offset] ?? 0;
+    if (inputByte < 0xfd) return inputByte;
+    return 1; // fallback for unusual cases
+  }
+
+  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
+    const { request } = await import('sats-connect');
+
+    const inputCount = this.countPsbtInputs(psbtBase64);
+    const signingIndexes = Array.from({ length: inputCount }, (_, i) => i);
+
+    const response = await request('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 as SignPsbtResult;
+
+    if (finalize) {
+      // Return hex for broadcast
+      return Buffer.from(result.psbt, 'base64').toString('hex');
+    }
+
+    // Return base64 signed PSBT (partially signed)
+    return result.psbt;
+  }
+
+  async signEcdsaMessage(message: string): Promise<string> {
+    const { request } = await import('sats-connect');
+
+    const response = await request('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 as SignMessageResult).signature;
+  }
+
+  async signBip322Message(message: string): Promise<string> {
+    const { request } = await import('sats-connect');
+
+    const response = await request('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 as SignMessageResult).signature;
+  }
+
+  async sendBitcoin(toAddress: string, satoshis: bigint): Promise<string> {
+    const { request } = await import('sats-connect');
+
+    const response = await request('sendTransfer', {
+      recipients: [
+        {
+          address: toAddress,
+          amount: Number(satoshis),
+        },
+      ],
+    });
+
+    if (response.status === 'error') {
+      throw new Error(response.error?.message || 'Xverse sendTransfer failed');
+    }
+
+    return (response.result as { txid: string }).txid;
+  }
+}
+
+export class XverseXConnector extends BitcoinXConnector {
+  private walletProvider: XverseWalletProvider | undefined;
+
+  constructor() {
+    super('Xverse', 'xverse');
+  }
+
+  public static isAvailable(): boolean {
+    return typeof window !== 'undefined' && !!window.BitcoinProvider;
+  }
+
+  public get icon(): string {
+    return 'https://cdn.brandfetch.io/iddzGN5Rcv/w/400/h/400/theme/dark/icon.jpeg?c=1bxid64Mup7aczewSAYMX&t=1771902357797';
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    if (!XverseXConnector.isAvailable()) {
+      throw new Error('Xverse wallet is not installed');
+    }
+
+    const { request } = await import('sats-connect');
+
+    const response = await request('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 as GetAccountsResult[];
+    const paymentAccount = accounts.find(a => a.purpose === AddressPurpose.Payment) || accounts[0];
+
+    if (!paymentAccount) return undefined;
+
+    this.walletProvider = new XverseWalletProvider(
+      paymentAccount.address,
+      paymentAccount.publicKey,
+    );
+
+    return {
+      address: paymentAccount.address,
+      publicKey: paymentAccount.publicKey,
+      xChainType: 'BITCOIN',
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    this.walletProvider = undefined;
+  }
+
+  getWalletProvider(): IBitcoinWalletProvider | undefined {
+    return this.walletProvider;
+  }
+
+  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
+    if (!xAccount.address || !xAccount.publicKey) return undefined;
+    return new XverseWalletProvider(xAccount.address, xAccount.publicKey);
+  }
+}