otx-btc-wallet-connectors 0.1.0

package/src/ledger/index.ts

@@ -0,0 +1,8 @@
+export { LedgerConnector } from './LedgerConnector';
+export type {
+  LedgerConnectorOptions,
+  LedgerAddressType,
+  LedgerUtxoInput,
+  LedgerTxOutput,
+  SendBitcoinOptions,
+} from './LedgerConnector';

package/src/okx/OKXConnector.ts

@@ -0,0 +1,230 @@
+import type {
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+} from 'otx-btc-wallet-core';
+import { BaseConnector } from '../base';
+
+/**
+ * OKX sign PSBT options
+ * @see https://web3.okx.com/build/dev-docs/sdks/chains/bitcoin/provider
+ */
+interface OKXSignPsbtOptions {
+  autoFinalized?: boolean;
+  toSignInputs?: Array<{
+    index: number;
+    address?: string;
+    publicKey?: string;
+    sighashTypes?: number[];
+    disableTweakSigner?: boolean;
+  }>;
+}
+
+/**
+ * OKX account changed event data
+ */
+interface OKXAccountChangedData {
+  address: string;
+  publicKey: string;
+  compressedPublicKey: string;
+}
+
+/**
+ * OKX Bitcoin provider interface
+ * @see https://web3.okx.com/build/dev-docs/sdks/chains/bitcoin/provider
+ */
+interface OKXBitcoinProvider {
+  connect(): Promise<{ address: string; publicKey: string }>;
+  requestAccounts(): Promise<string[]>;
+  getAccounts(): Promise<string[]>;
+  getPublicKey(): Promise<string>;
+  getNetwork(): Promise<string>;
+  getBalance(): Promise<{ confirmed: number; unconfirmed: number; total: number }>;
+  signMessage(message: string, type?: 'ecdsa' | 'bip322-simple'): Promise<string>;
+  signPsbt(psbtHex: string, options?: OKXSignPsbtOptions): Promise<string>;
+  signPsbts(psbtHexs: string[], options?: OKXSignPsbtOptions[]): Promise<string[]>;
+  pushPsbt(psbtHex: string): Promise<string>;
+  sendBitcoin(toAddress: string, satoshis: number, options?: { feeRate?: number }): Promise<string>;
+  on(event: 'accountChanged', callback: (data: OKXAccountChangedData) => void): void;
+  on(event: 'accountsChanged', callback: (addresses: string[]) => void): void;
+  on(event: 'networkChanged', callback: (network: string) => void): void;
+  removeListener(event: 'accountChanged', callback: (data: OKXAccountChangedData) => void): void;
+  removeListener(event: 'accountsChanged', callback: (addresses: string[]) => void): void;
+  removeListener(event: 'networkChanged', callback: (network: string) => void): void;
+}
+
+// Extend window type
+declare global {
+  interface Window {
+    okxwallet?: {
+      bitcoin?: OKXBitcoinProvider;
+    };
+  }
+}
+
+// OKX wallet icon
+const OKX_ICON =
+  'data:image/svg+xml;base64,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';
+
+/**
+ * OKX Wallet Connector
+ *
+ * @see https://www.okx.com/web3/build/docs/sdks/app-connect-overview
+ */
+export class OKXConnector extends BaseConnector {
+  readonly id = 'okx';
+  readonly name = 'OKX Wallet';
+  readonly icon = OKX_ICON;
+
+  private _unsubscribeAccounts?: () => void;
+  private _unsubscribeNetwork?: () => void;
+
+  protected getProvider(): OKXBitcoinProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return window.okxwallet?.bitcoin;
+  }
+
+  async connect(): Promise<WalletAccount> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const result = await provider.connect();
+
+      this.setupListeners();
+
+      return {
+        address: result.address,
+        publicKey: result.publicKey,
+        type: this.inferAddressType(result.address),
+      };
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    this._unsubscribeAccounts?.();
+    this._unsubscribeNetwork?.();
+    this.cleanup();
+  }
+
+  async getAccounts(): Promise<WalletAccount[]> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const addresses = await provider.getAccounts();
+      const publicKey = await provider.getPublicKey();
+
+      return addresses.map((address) => ({
+        address,
+        publicKey,
+        type: this.inferAddressType(address),
+      }));
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signMessage(message: string): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      return await provider.signMessage(message);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const okxOptions: OKXSignPsbtOptions = {
+        autoFinalized: options?.autoFinalize ?? true,
+      };
+
+      if (options?.toSignInputs) {
+        okxOptions.toSignInputs = options.toSignInputs;
+      }
+
+      return await provider.signPsbt(psbtHex, okxOptions);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async sendTransaction(to: string, satoshis: number): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      return await provider.sendBitcoin(to, satoshis);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async getNetwork(): Promise<BitcoinNetwork> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const network = await provider.getNetwork();
+      return this.mapNetwork(network);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  // OKX does not support switchNetwork via API - users must switch manually in extension
+
+  private setupListeners(): void {
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    // accountChanged returns object with address, publicKey, compressedPublicKey
+    const handleAccountChanged = (data: OKXAccountChangedData) => {
+      const walletAccount: WalletAccount = {
+        address: data.address,
+        publicKey: data.publicKey,
+        type: this.inferAddressType(data.address),
+      };
+      this.emitAccountsChanged([walletAccount]);
+    };
+
+    const handleNetworkChanged = (network: string) => {
+      const btcNetwork = this.mapNetwork(network);
+      this.emitNetworkChanged(btcNetwork);
+    };
+
+    provider.on('accountChanged', handleAccountChanged);
+    provider.on('networkChanged', handleNetworkChanged);
+
+    this._unsubscribeAccounts = () => {
+      provider.removeListener('accountChanged', handleAccountChanged);
+    };
+    this._unsubscribeNetwork = () => {
+      provider.removeListener('networkChanged', handleNetworkChanged);
+    };
+  }
+
+  private mapNetwork(network: string): BitcoinNetwork {
+    switch (network.toLowerCase()) {
+      case 'livenet':
+      case 'mainnet':
+        return 'mainnet';
+      case 'testnet':
+        return 'testnet';
+      case 'testnet4':
+        return 'testnet4';
+      case 'signet':
+        return 'signet';
+      default:
+        return 'mainnet';
+    }
+  }
+}

package/src/okx/index.ts

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

package/src/phantom/PhantomConnector.ts

@@ -0,0 +1,381 @@
+import type {
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+} from 'otx-btc-wallet-core';
+import * as bitcoin from 'bitcoinjs-lib';
+import { BaseConnector } from '../base';
+import { BtcService } from '../utils';
+import {
+  generatePsbtForSend,
+  finalizeAllInputs,
+  getBitcoinJsNetwork,
+  type GeneratePsbtOptions,
+} from '../utils';
+
+/**
+ * Options for sendTransaction method
+ */
+export interface PhantomSendOptions extends GeneratePsbtOptions {
+  // Additional Phantom-specific options can be added here
+}
+
+/**
+ * Phantom Bitcoin account type
+ * @see https://docs.phantom.com/bitcoin/establishing-a-connection
+ */
+interface BtcAccount {
+  address: string;
+  addressType: 'p2tr' | 'p2wpkh' | 'p2sh' | 'p2pkh';
+  publicKey: string;
+  purpose: 'payment' | 'ordinals';
+}
+
+/**
+ * Phantom Bitcoin provider interface
+ * @see https://docs.phantom.com/bitcoin/provider-api-reference
+ */
+interface PhantomBitcoinProvider {
+  isPhantom: boolean;
+  requestAccounts(): Promise<BtcAccount[]>;
+  signMessage(address: string, message: Uint8Array): Promise<{ signature: Uint8Array }>;
+  signPSBT(
+    psbt: Uint8Array,
+    options: {
+      inputsToSign: Array<{
+        address: string;
+        signingIndexes: number[];
+        sigHash?: number;
+      }>;
+    }
+  ): Promise<Uint8Array>;
+  on(event: 'accountsChanged', callback: (accounts: BtcAccount[]) => void): void;
+  off(event: 'accountsChanged', callback: (accounts: BtcAccount[]) => void): void;
+}
+
+// Extend window type
+declare global {
+  interface Window {
+    phantom?: {
+      bitcoin?: PhantomBitcoinProvider;
+    };
+  }
+}
+
+// Phantom wallet icon
+const PHANTOM_ICON =
+  'data:image/svg+xml;base64,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';
+
+/**
+ * Phantom Wallet Connector (Bitcoin support)
+ *
+ * @see https://docs.phantom.com/bitcoin/detecting-the-provider
+ */
+export class PhantomConnector extends BaseConnector {
+  readonly id = 'phantom';
+  readonly name = 'Phantom Wallet';
+  readonly icon = PHANTOM_ICON;
+
+  private _accounts: BtcAccount[] = [];
+  private _paymentAccount: WalletAccount | null = null;
+  private _ordinalsAccount: WalletAccount | null = null;
+  private _removeAccountChangeListener: (() => void) | null = null;
+
+  protected getProvider(): PhantomBitcoinProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    const provider = window.phantom?.bitcoin;
+    if (provider?.isPhantom) {
+      return provider;
+    }
+    return undefined;
+  }
+
+  async connect(): Promise<WalletAccount> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const accounts = await provider.requestAccounts();
+
+      if (!accounts || accounts.length === 0) {
+        throw new Error('No accounts returned');
+      }
+
+      this._accounts = accounts;
+      this.updateAccountsFromBtcAccounts(accounts);
+
+      // Setup event listeners
+      this.setupEventListeners();
+
+      if (!this._paymentAccount) {
+        throw new Error('No payment account found');
+      }
+
+      return this._paymentAccount;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private updateAccountsFromBtcAccounts(accounts: BtcAccount[]): void {
+    const paymentAcc = accounts.find((a) => a.purpose === 'payment');
+    const ordinalsAcc = accounts.find((a) => a.purpose === 'ordinals');
+
+    if (paymentAcc) {
+      this._paymentAccount = {
+        address: paymentAcc.address,
+        publicKey: paymentAcc.publicKey,
+        type: this.mapAddressType(paymentAcc.addressType),
+      };
+    }
+
+    if (ordinalsAcc) {
+      this._ordinalsAccount = {
+        address: ordinalsAcc.address,
+        publicKey: ordinalsAcc.publicKey,
+        type: this.mapAddressType(ordinalsAcc.addressType),
+      };
+    }
+  }
+
+  private mapAddressType(addressType: BtcAccount['addressType']): WalletAccount['type'] {
+    switch (addressType) {
+      case 'p2tr':
+        return 'taproot';
+      case 'p2wpkh':
+        return 'segwit';
+      case 'p2sh':
+        return 'nested-segwit';
+      case 'p2pkh':
+        return 'legacy';
+      default:
+        return 'legacy';
+    }
+  }
+
+  private setupEventListeners(): void {
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    // Remove existing listener
+    this.removeEventListeners();
+
+    // Account change listener
+    const handleAccountsChanged = (accounts: BtcAccount[]) => {
+      this._accounts = accounts;
+      this.updateAccountsFromBtcAccounts(accounts);
+
+      const walletAccounts: WalletAccount[] = accounts.map((acc) => ({
+        address: acc.address,
+        publicKey: acc.publicKey,
+        type: this.mapAddressType(acc.addressType),
+      }));
+
+      this.emitAccountsChanged(walletAccounts);
+    };
+
+    provider.on('accountsChanged', handleAccountsChanged);
+
+    this._removeAccountChangeListener = () => {
+      provider.off('accountsChanged', handleAccountsChanged);
+    };
+  }
+
+  private removeEventListeners(): void {
+    this._removeAccountChangeListener?.();
+    this._removeAccountChangeListener = null;
+  }
+
+  async disconnect(): Promise<void> {
+    this.removeEventListeners();
+    this._accounts = [];
+    this._paymentAccount = null;
+    this._ordinalsAccount = null;
+    this.cleanup();
+  }
+
+  async getAccounts(): Promise<WalletAccount[]> {
+    const accounts: WalletAccount[] = [];
+    if (this._paymentAccount) accounts.push(this._paymentAccount);
+    if (this._ordinalsAccount) accounts.push(this._ordinalsAccount);
+    return accounts;
+  }
+
+  async signMessage(message: string): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    if (!this._paymentAccount) {
+      throw new Error('Not connected');
+    }
+
+    try {
+      // Convert message to Uint8Array
+      const messageBytes = new TextEncoder().encode(message);
+      const result = await provider.signMessage(this._paymentAccount.address, messageBytes);
+      // Convert Uint8Array signature to hex string
+      return bytesToHex(result.signature);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    if (!this._paymentAccount) {
+      throw new Error('Not connected');
+    }
+
+    try {
+      // Convert hex to Uint8Array
+      const psbtBytes = hexToBytes(psbtHex);
+
+      // Build inputsToSign
+      const allAddresses = this._accounts.map((a) => a.address);
+      let inputsToSign: Array<{ address: string; signingIndexes: number[]; sigHash?: number }>;
+
+      if (options?.toSignInputs && options.toSignInputs.length > 0) {
+        inputsToSign = options.toSignInputs.map((input) => {
+          const addr = input.address && allAddresses.includes(input.address)
+            ? input.address
+            : this._paymentAccount!.address;
+
+          const item: { address: string; signingIndexes: number[]; sigHash?: number } = {
+            address: addr,
+            signingIndexes: [input.index],
+          };
+
+          if (input.sighashTypes && input.sighashTypes[0] !== undefined) {
+            item.sigHash = input.sighashTypes[0];
+          }
+
+          return item;
+        });
+      } else {
+        // Default: sign all inputs with payment address
+        inputsToSign = [{
+          address: this._paymentAccount.address,
+          signingIndexes: [0],
+        }];
+      }
+
+      const signedPsbt = await provider.signPSBT(psbtBytes, { inputsToSign });
+
+      // Convert back to hex
+      return bytesToHex(signedPsbt);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * Send Bitcoin transaction
+   * Builds a PSBT, signs it with Phantom, and broadcasts
+   *
+   * @param to - Recipient address
+   * @param satoshis - Amount to send in satoshis
+   * @param options - Send options (feeRate, etc.)
+   * @returns Transaction ID after broadcast
+   */
+  async sendTransaction(
+    to: string,
+    satoshis: number,
+    options?: PhantomSendOptions
+  ): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    if (!this._paymentAccount) {
+      throw new Error('Not connected. Please call connect() first.');
+    }
+
+    const network: BitcoinNetwork = 'mainnet'; // Phantom only supports mainnet
+    const btcNetwork = getBitcoinJsNetwork(network);
+
+    // 1. Generate PSBT using the utility
+    const {
+      psbt,
+      selectedUtxos,
+      inputsToSign,
+    } = await generatePsbtForSend(
+      to,
+      satoshis,
+      this._paymentAccount.address,
+      this._paymentAccount.publicKey,
+      network,
+      options
+    );
+
+    // 2. Convert PSBT to Uint8Array for Phantom
+    const psbtBytes = psbt.toBuffer();
+
+    // 3. Build inputsToSign for Phantom API
+    const phantomInputsToSign = [{
+      address: this._paymentAccount.address,
+      signingIndexes: inputsToSign.map((input) => input.index),
+    }];
+
+    // 4. Sign PSBT with Phantom
+    const signedPsbtBytes = await provider.signPSBT(psbtBytes, {
+      inputsToSign: phantomInputsToSign,
+    });
+
+    // 5. Parse signed PSBT and finalize
+    const signedPsbt = bitcoin.Psbt.fromBuffer(
+      new Uint8Array(signedPsbtBytes),
+      { network: btcNetwork }
+    );
+    finalizeAllInputs(signedPsbt, selectedUtxos.length);
+
+    // 6. Extract transaction
+    const tx = signedPsbt.extractTransaction();
+    const txHex = tx.toHex();
+
+    // 7. Broadcast using BtcService
+    const btcService = new BtcService(network);
+    return await btcService.broadcastTransaction(txHex);
+  }
+
+  async getNetwork(): Promise<BitcoinNetwork> {
+    // Phantom Bitcoin only supports mainnet currently
+    return 'mainnet';
+  }
+
+  /**
+   * Get the ordinals address (if available)
+   */
+  getOrdinalsAddress(): WalletAccount | null {
+    return this._ordinalsAccount;
+  }
+
+  /**
+   * Get the payment address
+   */
+  getPaymentAddress(): WalletAccount | null {
+    return this._paymentAccount;
+  }
+
+  /**
+   * Get all connected addresses
+   */
+  getAllAddresses(): string[] {
+    return this._accounts.map((acc) => acc.address);
+  }
+}
+
+// Helper functions for hex/bytes conversion
+function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}

package/src/phantom/index.ts

@@ -0,0 +1,2 @@
+export { PhantomConnector } from './PhantomConnector';
+export type { PhantomSendOptions } from './PhantomConnector';