otx-btc-wallet-connectors 0.1.0

package/src/trezor/index.ts

@@ -0,0 +1,6 @@
+export { TrezorConnector } from './TrezorConnector';
+export type {
+  TrezorConnectorOptions,
+  TrezorAddressType,
+  TrezorSendBitcoinOptions,
+} from './TrezorConnector';

package/src/unisat/UnisatConnector.ts

@@ -0,0 +1,312 @@
+import type {
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+} from 'otx-btc-wallet-core';
+import { BaseConnector } from '../base';
+
+/**
+ * Unisat network types
+ * @see https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#switchnetwork
+ */
+type UnisatNetwork = 'livenet' | 'testnet' | 'testnet4' | 'signet';
+
+// Unisat wallet provider type
+interface UnisatProvider {
+  requestAccounts(): Promise<string[]>;
+  getAccounts(): Promise<string[]>;
+  getPublicKey(): Promise<string>;
+  getNetwork(): Promise<string>;
+  getChain(): Promise<{
+    enum: string
+    name: string
+    network: string
+  }>
+  switchChain(chain: string): Promise<{
+    enum: string
+    name: string
+    network: string
+  }>
+  switchNetwork(network: UnisatNetwork): Promise<void>;
+  signMessage(message: string, type?: string): Promise<string>;
+  signPsbt(psbtHex: string, options?: UnisatSignOptions): Promise<string>;
+  signPsbts(psbtHexs: string[], options?: UnisatSignOptions[]): Promise<string[]>;
+  sendBitcoin(to: string, satoshis: number, options?: object): Promise<string>;
+  on(event: string, callback: (arg: unknown) => void): void;
+  removeListener(event: string, callback: (arg: unknown) => void): void;
+}
+
+interface UnisatSignOptions {
+  autoFinalized?: boolean;
+  toSignInputs?: Array<{
+    index: number;
+    address?: string;
+    publicKey?: string;
+    sighashTypes?: number[];
+    disableTweakSigner?: boolean;
+  }>;
+}
+
+// Extend window type
+declare global {
+  interface Window {
+    unisat_wallet?: UnisatProvider;
+  }
+}
+
+// Unisat wallet icon (SVG as base64)
+const UNISAT_ICON =
+  'data:image/svg+xml;base64,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';
+
+/**
+ * Unisat Wallet Connector
+ *
+ * @see https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet
+ */
+export class UnisatConnector extends BaseConnector {
+  readonly id = 'unisat';
+  readonly name = 'Unisat Wallet';
+  readonly icon = UNISAT_ICON;
+  readonly BITCOIN_TESTNET4 = 'BITCOIN_TESTNET4'
+  private _unsubscribeAccounts?: () => void;
+  private _unsubscribeNetwork?: () => void;
+
+  protected getProvider(): UnisatProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return window.unisat_wallet;
+  }
+
+  async connect(network: BitcoinNetwork = 'mainnet'): Promise<WalletAccount> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      // First request accounts to trigger wallet popup
+      const initialAccounts = await provider.requestAccounts();
+      if (!initialAccounts || initialAccounts.length === 0) {
+        throw new Error('No accounts found');
+      }
+
+      // Switch network if needed
+      await this.checkAndSwitchNetwork(provider, network);
+
+      // Get accounts AFTER network switch (address changes per network)
+      const accounts = await provider.getAccounts();
+      const publicKey = await provider.getPublicKey();
+
+      // Setup event listeners
+      this.setupListeners();
+
+      return {
+        address: accounts[0] ?? '',
+        publicKey,
+        type: this.inferAddressType(accounts[0] ?? ''),
+      };
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    // Unisat doesn't have a disconnect method, just cleanup listeners
+    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 unisatOptions: UnisatSignOptions = {
+        autoFinalized: options?.autoFinalize ?? true,
+      };
+
+      // Only add toSignInputs if defined
+      if (options?.toSignInputs) {
+        unisatOptions.toSignInputs = options.toSignInputs;
+      }
+      return await provider.signPsbt(psbtHex, unisatOptions);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbts(
+    psbtHexs: string[],
+    options?: SignPsbtOptions
+  ): Promise<string[]> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const unisatOptions: UnisatSignOptions = {
+        autoFinalized: options?.autoFinalize ?? true,
+      };
+
+      // Only add toSignInputs if defined
+      if (options?.toSignInputs) {
+        unisatOptions.toSignInputs = options.toSignInputs;
+      }
+
+      // Create options array for each PSBT
+      const optionsArray = psbtHexs.map(() => unisatOptions);
+
+      return await provider.signPsbts(psbtHexs, optionsArray);
+    } 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);
+    }
+  }
+
+  async switchNetwork(network: BitcoinNetwork): Promise<void> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const unisatNetwork = this.mapToUnisatNetwork(network);
+      await provider.switchNetwork(unisatNetwork);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private async checkAndSwitchNetwork(provider: UnisatProvider, network: BitcoinNetwork): Promise<void> {
+    const currentNetwork = await provider.getNetwork();
+    const targetNetwork = this.mapToUnisatNetwork(network);
+    if (currentNetwork !== targetNetwork) {
+      await provider.switchNetwork(targetNetwork);
+    }
+    // testnet4 requires additional chain switch
+    if (network === 'testnet4') {
+      const currentChain = await provider.getChain();
+      if (currentChain.enum !== this.BITCOIN_TESTNET4) {
+        await provider.switchChain(this.BITCOIN_TESTNET4);
+      }
+    }
+  }
+
+  private setupListeners(): void {
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    // Account change listener - wrap to handle unknown arg type
+    const handleAccountsChanged = (arg: unknown) => {
+      const accounts = arg as string[];
+      if (!Array.isArray(accounts) || accounts.length === 0) {
+        this.emitAccountsChanged([]);
+        return;
+      }
+
+      provider.getPublicKey().then((publicKey) => {
+        const walletAccounts: WalletAccount[] = accounts.map((address) => ({
+          address,
+          publicKey,
+          type: this.inferAddressType(address),
+        }));
+        this.emitAccountsChanged(walletAccounts);
+      }).catch(() => {
+        // If we can't get public key, emit empty to trigger disconnect
+        this.emitAccountsChanged([]);
+      });
+    };
+
+    // Network change listener
+    const handleNetworkChanged = (arg: unknown) => {
+      const network = arg as string;
+      const btcNetwork = this.mapNetwork(network);
+      this.emitNetworkChanged(btcNetwork);
+    };
+
+    provider.on('accountsChanged', handleAccountsChanged);
+    provider.on('networkChanged', handleNetworkChanged);
+
+    this._unsubscribeAccounts = () => {
+      provider.removeListener('accountsChanged', handleAccountsChanged);
+    };
+    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';
+    }
+  }
+
+  private mapToUnisatNetwork(network: BitcoinNetwork): UnisatNetwork {
+    switch (network) {
+      case 'mainnet':
+        return 'livenet';
+      case 'testnet':
+      case 'testnet4':
+        return 'testnet';
+      case 'signet':
+        return 'signet';
+      default:
+        return 'livenet';
+    }
+  }
+}

package/src/unisat/index.ts

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

package/src/utils/blockstream.ts

@@ -0,0 +1,230 @@
+import type { BitcoinNetwork } from 'otx-btc-wallet-core';
+import type {
+  IBtcService,
+  Utxo,
+  UtxoWithTx,
+  FeeRates,
+  Transaction,
+  FullTransaction,
+  AddressBalance,
+  NetworkEndpoints,
+} from './types';
+
+/**
+ * Default API endpoints for blockstream.info
+ * Note: Blockstream doesn't support testnet4 and signet, fallback to mempool for those
+ */
+const DEFAULT_BLOCKSTREAM_ENDPOINTS: Record<BitcoinNetwork, string> = {
+  mainnet: 'https://blockstream.info/api',
+  testnet: 'https://blockstream.info/testnet/api',
+  testnet4: 'https://mempool.space/testnet4/api', // Fallback to mempool
+  signet: 'https://mempool.space/signet/api', // Fallback to mempool
+};
+
+/**
+ * Fetch with timeout helper
+ */
+async function fetchWithTimeout(
+  url: string,
+  options?: RequestInit,
+  timeout: number = 10000
+): Promise<Response> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+
+/**
+ * Blockstream.info Bitcoin Service
+ *
+ * @see https://github.com/Blockstream/esplora/blob/master/API.md
+ *
+ * @example
+ * ```typescript
+ * // Default usage
+ * const service = new BlockstreamService('mainnet');
+ *
+ * // With custom endpoints
+ * const service = new BlockstreamService('mainnet', {
+ *   mainnet: 'https://my-esplora-proxy.com/api',
+ *   testnet: 'https://my-esplora-proxy.com/testnet/api',
+ * });
+ * ```
+ */
+export class BlockstreamService implements IBtcService {
+  readonly name = 'blockstream';
+  private _network: BitcoinNetwork;
+  private _customEndpoints: NetworkEndpoints;
+
+  constructor(network: BitcoinNetwork = 'mainnet', customEndpoints?: NetworkEndpoints) {
+    this._network = network;
+    this._customEndpoints = customEndpoints ?? {};
+  }
+
+  get network(): BitcoinNetwork {
+    return this._network;
+  }
+
+  private get baseUrl(): string {
+    // Use custom endpoint if provided, otherwise use default
+    return this._customEndpoints[this._network] ?? DEFAULT_BLOCKSTREAM_ENDPOINTS[this._network];
+  }
+
+  setNetwork(network: BitcoinNetwork): void {
+    this._network = network;
+  }
+
+  /**
+   * Set custom endpoints for this service
+   */
+  setCustomEndpoints(endpoints: NetworkEndpoints): void {
+    this._customEndpoints = { ...this._customEndpoints, ...endpoints };
+  }
+
+  /**
+   * Get current endpoints configuration
+   */
+  getEndpoints(): Record<BitcoinNetwork, string> {
+    return {
+      mainnet: this._customEndpoints.mainnet ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.mainnet,
+      testnet: this._customEndpoints.testnet ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.testnet,
+      testnet4: this._customEndpoints.testnet4 ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.testnet4,
+      signet: this._customEndpoints.signet ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.signet,
+    };
+  }
+
+  // ============ UTXO Methods ============
+
+  async getUtxos(address: string): Promise<Utxo[]> {
+    const response = await fetchWithTimeout(`${this.baseUrl}/address/${address}/utxo`);
+
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<Utxo[]>;
+  }
+
+  async getUtxosWithTxHex(address: string): Promise<UtxoWithTx[]> {
+    const utxos = await this.getUtxos(address);
+
+    const utxosWithTx = await Promise.all(
+      utxos.map(async (utxo): Promise<UtxoWithTx> => {
+        const txHex = await this.getTxHex(utxo.txid);
+        return { ...utxo, txHex };
+      })
+    );
+
+    return utxosWithTx;
+  }
+
+  // ============ Transaction Methods ============
+
+  async getTxHex(txid: string): Promise<string> {
+    const response = await fetchWithTimeout(`${this.baseUrl}/tx/${txid}/hex`);
+
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.text();
+  }
+
+  async getTransaction(txid: string): Promise<Transaction> {
+    const response = await fetchWithTimeout(`${this.baseUrl}/tx/${txid}`);
+
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<Transaction>;
+  }
+
+  async getFullTransaction(txid: string): Promise<FullTransaction> {
+    const response = await fetchWithTimeout(`${this.baseUrl}/tx/${txid}`);
+
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<FullTransaction>;
+  }
+
+  async broadcastTransaction(txHex: string): Promise<string> {
+    const response = await fetchWithTimeout(
+      `${this.baseUrl}/tx`,
+      {
+        method: 'POST',
+        body: txHex,
+        headers: { 'Content-Type': 'text/plain' },
+      },
+      30000
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Blockstream broadcast error: ${error}`);
+    }
+
+    return response.text();
+  }
+
+  // ============ Address Methods ============
+
+  async getAddressInfo(address: string): Promise<AddressBalance> {
+    const response = await fetchWithTimeout(`${this.baseUrl}/address/${address}`);
+
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<AddressBalance>;
+  }
+
+  async getBalance(address: string): Promise<number> {
+    const info = await this.getAddressInfo(address);
+    const confirmedBalance =
+      info.chain_stats.funded_txo_sum - info.chain_stats.spent_txo_sum;
+    const unconfirmedBalance =
+      info.mempool_stats.funded_txo_sum - info.mempool_stats.spent_txo_sum;
+    return confirmedBalance + unconfirmedBalance;
+  }
+
+  async getConfirmedBalance(address: string): Promise<number> {
+    const info = await this.getAddressInfo(address);
+    return info.chain_stats.funded_txo_sum - info.chain_stats.spent_txo_sum;
+  }
+
+  // ============ Fee Methods ============
+
+  async getFeeRates(): Promise<FeeRates> {
+    // Blockstream uses mempool.space fee API format
+    const response = await fetchWithTimeout(`${this.baseUrl}/fee-estimates`);
+
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+
+    const fees = (await response.json()) as Record<string, number>;
+    // Blockstream returns fee estimates keyed by confirmation target
+    // e.g., { "1": 25.5, "2": 20.1, "3": 15.2, ... }
+    return {
+      fastest: Math.ceil(fees['1'] || fees['2'] || 10),
+      halfHour: Math.ceil(fees['3'] || fees['4'] || 8),
+      hour: Math.ceil(fees['6'] || fees['12'] || 5),
+      economy: Math.ceil(fees['144'] || fees['504'] || 2),
+      minimum: Math.ceil(fees['1008'] || 1),
+    };
+  }
+}