otx-btc-wallet-connectors 0.1.0

package/src/xverse/XverseConnector.ts

@@ -0,0 +1,479 @@
+import type {
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+} from 'otx-btc-wallet-core';
+import { BaseConnector } from '../base';
+
+/**
+ * Address purpose enum for Xverse
+ */
+enum AddressPurpose {
+  Payment = 'payment',
+  Ordinals = 'ordinals',
+}
+
+/**
+ * Xverse address response
+ */
+interface AddressResponse {
+  address: string;
+  publicKey: string;
+  purpose: AddressPurpose;
+}
+
+/**
+ * Xverse Provider request/response types
+ */
+interface XverseRequestResponse<T> {
+  result: T;
+  error?: { message: string };
+}
+
+interface GetAddressesResult {
+  addresses: AddressResponse[];
+}
+
+interface SignMessageResult {
+  signature: string;
+}
+
+interface SignPsbtResult {
+  psbt: string;
+  txid?: string;
+}
+
+interface SendTransferResult {
+  txid: string;
+}
+
+interface NetworkResult {
+  bitcoin?: { name: string };
+}
+
+interface XverseEventData {
+  network?: string;
+}
+
+/**
+ * Xverse Bitcoin Provider interface
+ */
+interface XverseBitcoinProvider {
+  request<T>(method: string, params: unknown): Promise<XverseRequestResponse<T>>;
+  addListener(event: string, callback: (data: XverseEventData) => void): () => void;
+}
+
+// Extend window type
+declare global {
+  interface Window {
+    XverseProviders?: {
+      BitcoinProvider?: XverseBitcoinProvider;
+    };
+  }
+}
+
+// Xverse wallet icon
+const XVERSE_ICON =
+  'data:image/svg+xml;base64,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';
+
+/**
+ * Xverse Wallet Connector
+ * Uses the native Xverse Provider API
+ *
+ * @see https://docs.xverse.app/
+ */
+export class XverseConnector extends BaseConnector {
+  readonly id = 'xverse';
+  readonly name = 'Xverse Wallet';
+  readonly icon = XVERSE_ICON;
+
+  private _paymentAddress: WalletAccount | null = null;
+  private _ordinalsAddress: WalletAccount | null = null;
+  private _network: BitcoinNetwork = 'mainnet';
+  private _accounts: AddressResponse[] = [];
+  private _removeAccountChangeListener: (() => void) | null = null;
+  private _removeNetworkChangeListener: (() => void) | null = null;
+  private _removeDisconnectedListener: (() => void) | null = null;
+
+  protected getProvider(): XverseBitcoinProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return window.XverseProviders?.BitcoinProvider;
+  }
+
+  async connect(network: BitcoinNetwork = 'mainnet'): Promise<WalletAccount> {
+    const provider = this.getProvider();
+    if (!provider) {
+      this.handleError(new Error('Xverse Wallet is not installed'));
+    }
+
+    try {
+      this._network = network;
+
+      // Request permissions first
+      const permissionResponse = await provider!.request<unknown>('wallet_requestPermissions', undefined);
+      if (permissionResponse.error) {
+        throw new Error(permissionResponse.error.message);
+      }
+
+      // Get addresses
+      const response = await provider!.request<GetAddressesResult>('getAddresses', {
+        purposes: [AddressPurpose.Payment, AddressPurpose.Ordinals],
+        message: 'Connect to application',
+      });
+
+      if (response.error) {
+        throw response.error;
+      }
+
+      const addresses = response.result.addresses;
+      this._accounts = addresses;
+
+      const paymentAddr = addresses.find((a) => a.purpose === AddressPurpose.Payment);
+      const ordinalsAddr = addresses.find((a) => a.purpose === AddressPurpose.Ordinals);
+
+      if (paymentAddr) {
+        this._paymentAddress = {
+          address: paymentAddr.address,
+          publicKey: paymentAddr.publicKey,
+          type: this.inferAddressType(paymentAddr.address),
+        };
+      }
+
+      if (ordinalsAddr) {
+        this._ordinalsAddress = {
+          address: ordinalsAddr.address,
+          publicKey: ordinalsAddr.publicKey,
+          type: this.inferAddressType(ordinalsAddr.address),
+        };
+      }
+
+      // Check and switch network if needed
+      await this.checkAndSwitchNetwork(network);
+
+      // Setup event listeners
+      this.setupEventListeners();
+
+      if (!this._paymentAddress) {
+        throw new Error('No payment address found');
+      }
+
+      return this._paymentAddress;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private async checkAndSwitchNetwork(network: BitcoinNetwork): Promise<void> {
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    // For testnet4, we need to switch to Testnet4 network in Xverse
+    if (network === 'testnet4') {
+      try {
+        const currentNetwork = await provider.request<NetworkResult>('wallet_getNetwork', null);
+        if (currentNetwork?.result?.bitcoin?.name !== 'Testnet4') {
+          await provider.request<unknown>('wallet_changeNetwork', { name: 'Testnet4' });
+        }
+      } catch {
+        // Network switch may not be supported, continue anyway
+      }
+    } else if (network === 'testnet') {
+      try {
+        const currentNetwork = await provider.request<NetworkResult>('wallet_getNetwork', null);
+        if (currentNetwork?.result?.bitcoin?.name !== 'Testnet') {
+          await provider.request<unknown>('wallet_changeNetwork', { name: 'Testnet' });
+        }
+      } catch {
+        // Network switch may not be supported
+      }
+    } else if (network === 'mainnet') {
+      try {
+        const currentNetwork = await provider.request<NetworkResult>('wallet_getNetwork', null);
+        if (currentNetwork?.result?.bitcoin?.name !== 'Mainnet') {
+          await provider.request<unknown>('wallet_changeNetwork', { name: 'Mainnet' });
+        }
+      } catch {
+        // Network switch may not be supported
+      }
+    }
+  }
+
+  private setupEventListeners(): void {
+    const provider = this.getProvider();
+    if (!provider || typeof provider.addListener !== 'function') return;
+
+    // Remove existing listeners
+    this.removeEventListeners();
+
+    // Account change listener
+    this._removeAccountChangeListener = provider.addListener('accountChange', async () => {
+      await this.handleAccountChange();
+    });
+
+    // Network change listener
+    this._removeNetworkChangeListener = provider.addListener('networkChange', async (event) => {
+      await this.handleNetworkChange(event);
+    });
+
+    // Disconnected listener
+    this._removeDisconnectedListener = provider.addListener('accountDisconnected', () => {
+      this.emitAccountsChanged([]);
+    });
+  }
+
+  private async handleAccountChange(): Promise<void> {
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    try {
+      const response = await provider.request<GetAddressesResult>('getAddresses', {
+        purposes: [AddressPurpose.Payment, AddressPurpose.Ordinals],
+      });
+
+      if (!response.error && response.result?.addresses?.length) {
+        this._accounts = response.result.addresses;
+        const paymentAddr = response.result.addresses.find((a) => a.purpose === AddressPurpose.Payment);
+
+        if (paymentAddr) {
+          this._paymentAddress = {
+            address: paymentAddr.address,
+            publicKey: paymentAddr.publicKey,
+            type: this.inferAddressType(paymentAddr.address),
+          };
+
+          const accounts: WalletAccount[] = response.result.addresses.map((addr) => ({
+            address: addr.address,
+            publicKey: addr.publicKey,
+            type: this.inferAddressType(addr.address),
+          }));
+
+          this.emitAccountsChanged(accounts);
+        }
+      }
+    } catch (error) {
+      console.error('Error handling account change:', error);
+    }
+  }
+
+  private async handleNetworkChange(event: XverseEventData): Promise<void> {
+    if (!event.network) return;
+
+    const networkMap: Record<string, BitcoinNetwork> = {
+      'Mainnet': 'mainnet',
+      'Testnet': 'testnet',
+      'Testnet4': 'testnet4',
+      'Signet': 'signet',
+    };
+
+    const mappedNetwork = networkMap[event.network] || 'mainnet';
+    if (mappedNetwork !== this._network) {
+      this._network = mappedNetwork;
+      this.emitNetworkChanged(mappedNetwork);
+    }
+  }
+
+  private removeEventListeners(): void {
+    this._removeAccountChangeListener?.();
+    this._removeAccountChangeListener = null;
+
+    this._removeNetworkChangeListener?.();
+    this._removeNetworkChangeListener = null;
+
+    this._removeDisconnectedListener?.();
+    this._removeDisconnectedListener = null;
+  }
+
+  async disconnect(): Promise<void> {
+    const provider = this.getProvider();
+
+    try {
+      if (provider) {
+        await provider.request<unknown>('wallet_renouncePermissions', undefined);
+      }
+    } catch {
+      // Ignore disconnect errors
+    } finally {
+      this.removeEventListeners();
+      this._paymentAddress = null;
+      this._ordinalsAddress = null;
+      this._accounts = [];
+      this.cleanup();
+    }
+  }
+
+  async getAccounts(): Promise<WalletAccount[]> {
+    const accounts: WalletAccount[] = [];
+    if (this._paymentAddress) accounts.push(this._paymentAddress);
+    if (this._ordinalsAddress) accounts.push(this._ordinalsAddress);
+    return accounts;
+  }
+
+  async signMessage(message: string): Promise<string> {
+    const provider = this.getProvider();
+    if (!provider) {
+      throw new Error('Xverse Wallet is not installed');
+    }
+    if (!this._paymentAddress) {
+      throw new Error('Not connected');
+    }
+
+    try {
+      const response = await provider.request<SignMessageResult>('signMessage', {
+        address: this._paymentAddress.address,
+        message,
+      });
+
+      if (response.error) {
+        throw response.error;
+      }
+
+      return response.result.signature;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+    const provider = this.getProvider();
+    if (!provider) {
+      throw new Error('Xverse Wallet is not installed');
+    }
+
+    if (!this._paymentAddress) {
+      throw new Error('Not connected');
+    }
+
+    try {
+      // Convert hex to base64 for Xverse
+      const psbtBase64 = Buffer.from(psbtHex, 'hex').toString('base64');
+
+      // Build signInputs map
+      const signInputs: Record<string, number[]> = {};
+      const allAddresses = this._accounts.map((a) => a.address);
+
+      if (options?.toSignInputs && options.toSignInputs.length > 0) {
+        for (const input of options.toSignInputs) {
+          const addr = input.address && allAddresses.includes(input.address)
+            ? input.address
+            : this._paymentAddress.address;
+
+          if (!signInputs[addr]) {
+            signInputs[addr] = [];
+          }
+          signInputs[addr]!.push(input.index);
+        }
+
+        // If no matching addresses found, use payment address
+        if (Object.keys(signInputs).length === 0) {
+          signInputs[this._paymentAddress.address] = options.toSignInputs.map((i) => i.index);
+        }
+      } else {
+        // Default: sign all inputs with payment address
+        signInputs[this._paymentAddress.address] = [0];
+      }
+
+      const response = await provider.request<SignPsbtResult>('signPsbt', {
+        psbt: psbtBase64,
+        signInputs,
+        broadcast: options?.broadcast ?? false,
+        allowedSignHash: options?.toSignInputs?.[0]?.sighashTypes?.[0],
+      });
+      if (response.error) {
+        throw response.error;
+      }
+
+      // Return txid if broadcast, otherwise return signed psbt as hex
+      if (response.result.txid) {
+        return response.result.txid;
+      }
+
+      // Convert base64 back to hex
+      return Buffer.from(response.result.psbt, 'base64').toString('hex');
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async sendTransaction(to: string, satoshis: number): Promise<string> {
+    const provider = this.getProvider();
+    if (!provider) {
+      throw new Error('Xverse Wallet is not installed');
+    }
+
+    if (!this._paymentAddress) {
+      throw new Error('Not connected');
+    }
+
+    try {
+      const response = await provider.request<SendTransferResult>('sendTransfer', {
+        recipients: [
+          {
+            address: to,
+            amount: satoshis,
+          },
+        ],
+      });
+
+      if (response.error) {
+        throw response.error;
+      }
+
+      if (!response.result.txid) {
+        throw new Error('No transaction ID received');
+      }
+
+      return response.result.txid;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async getNetwork(): Promise<BitcoinNetwork> {
+    return this._network;
+  }
+
+  async switchNetwork(network: BitcoinNetwork): Promise<void> {
+    await this.checkAndSwitchNetwork(network);
+    this._network = network;
+    this.emitNetworkChanged(network);
+  }
+
+  /**
+   * Get the ordinals address (if available)
+   */
+  getOrdinalsAddress(): WalletAccount | null {
+    return this._ordinalsAddress;
+  }
+
+  /**
+   * Get the payment address
+   */
+  getPaymentAddress(): WalletAccount | null {
+    return this._paymentAddress;
+  }
+
+  /**
+   * Get all connected addresses (for multi-address support)
+   */
+  getAllAddresses(): string[] {
+    return this._accounts.map((acc) => acc.address);
+  }
+
+  /**
+   * Switch to a specific address within the connected accounts
+   */
+  switchWalletAddress(address: string): boolean {
+    const account = this._accounts.find((a) => a.address === address);
+    if (account) {
+      if (account.purpose === AddressPurpose.Payment) {
+        this._paymentAddress = {
+          address: account.address,
+          publicKey: account.publicKey,
+          type: this.inferAddressType(account.address),
+        };
+      }
+      return true;
+    }
+    return false;
+  }
+}

package/src/xverse/index.ts

@@ -0,0 +1 @@
+export { XverseConnector } from './XverseConnector';