otx-btc-wallet-connectors 0.1.0

package/dist/xverse/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkEIJOSZXZ_js = require('../chunk-EIJOSZXZ.js');
+require('../chunk-MFXLQWOE.js');
+
+
+
+Object.defineProperty(exports, "XverseConnector", {
+  enumerable: true,
+  get: function () { return chunkEIJOSZXZ_js.XverseConnector; }
+});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map

package/dist/xverse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/xverse/index.mjs

@@ -0,0 +1,4 @@
+export { XverseConnector } from '../chunk-RLZEG6KL.mjs';
+import '../chunk-5Z5Q2Y75.mjs';
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/xverse/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "otx-btc-wallet-connectors",
+  "version": "0.1.0",
+  "description": "Bitcoin wallet connectors for otx-btc-wallet",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./unisat": {
+      "import": "./dist/unisat/index.mjs",
+      "require": "./dist/unisat/index.js",
+      "types": "./dist/unisat/index.d.ts"
+    },
+    "./xverse": {
+      "import": "./dist/xverse/index.mjs",
+      "require": "./dist/xverse/index.js",
+      "types": "./dist/xverse/index.d.ts"
+    },
+    "./okx": {
+      "import": "./dist/okx/index.mjs",
+      "require": "./dist/okx/index.js",
+      "types": "./dist/okx/index.d.ts"
+    },
+    "./leather": {
+      "import": "./dist/leather/index.mjs",
+      "require": "./dist/leather/index.js",
+      "types": "./dist/leather/index.d.ts"
+    },
+    "./phantom": {
+      "import": "./dist/phantom/index.mjs",
+      "require": "./dist/phantom/index.js",
+      "types": "./dist/phantom/index.d.ts"
+    },
+    "./bitget": {
+      "import": "./dist/bitget/index.mjs",
+      "require": "./dist/bitget/index.js",
+      "types": "./dist/bitget/index.d.ts"
+    },
+    "./binance": {
+      "import": "./dist/binance/index.mjs",
+      "require": "./dist/binance/index.js",
+      "types": "./dist/binance/index.d.ts"
+    },
+    "./ledger": {
+      "import": "./dist/ledger/index.mjs",
+      "require": "./dist/ledger/index.js",
+      "types": "./dist/ledger/index.d.ts"
+    },
+    "./trezor": {
+      "import": "./dist/trezor/index.mjs",
+      "require": "./dist/trezor/index.js",
+      "types": "./dist/trezor/index.d.ts"
+    },
+    "./imtoken": {
+      "import": "./dist/imtoken/index.mjs",
+      "require": "./dist/imtoken/index.js",
+      "types": "./dist/imtoken/index.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils/index.mjs",
+      "require": "./dist/utils/index.js",
+      "types": "./dist/utils/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@ledgerhq/hw-app-btc": "^10.4.1",
+    "@ledgerhq/hw-transport-webusb": "^6.30.0",
+    "@trezor/connect-web": "^9.4.3",
+    "bitcoinjs-lib": "^7.0.1",
+    "sats-connect": "^2.2.0",
+    "otx-btc-wallet-core": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.2",
+    "tsup": "^8.0.1"
+  },
+  "keywords": [
+    "bitcoin",
+    "wallet",
+    "unisat",
+    "xverse",
+    "okx",
+    "leather",
+    "phantom",
+    "bitget",
+    "binance",
+    "ledger",
+    "trezor",
+    "imtoken"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/base.ts

@@ -0,0 +1,132 @@
+import type {
+  BitcoinConnector,
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+  AddressType,
+} from 'otx-btc-wallet-core';
+
+/**
+ * Abstract base class for all wallet connectors
+ * Provides common functionality and enforces the BitcoinConnector interface
+ */
+export abstract class BaseConnector implements BitcoinConnector {
+  abstract readonly id: string;
+  abstract readonly name: string;
+  abstract readonly icon: string;
+
+  private _ready = false;
+  private _accountsChangedCallbacks: Set<(accounts: WalletAccount[]) => void> =
+    new Set();
+  private _networkChangedCallbacks: Set<(network: BitcoinNetwork) => void> =
+    new Set();
+
+  constructor() {
+    this.checkReady();
+    // Some wallets inject after DOMContentLoaded
+    if (typeof window !== 'undefined') {
+      if (document.readyState === 'complete') {
+        this.checkReady();
+      } else {
+        window.addEventListener('load', () => this.checkReady());
+      }
+    }
+  }
+
+  get ready(): boolean {
+    return this._ready;
+  }
+
+  protected set ready(value: boolean) {
+    this._ready = value;
+  }
+  protected abstract getProvider(): unknown;
+  protected checkReady(): void {
+    this._ready = !!this.getProvider();
+  }
+  protected ensureInstalled(): void {
+    if (!this.ready) {
+      throw new Error(`${this.name} wallet is not installed`);
+    }
+  }
+  protected inferAddressType(address: string): AddressType {
+    if (address.startsWith('bc1q') || address.startsWith('tb1q')) {
+      return 'segwit';
+    }
+    if (address.startsWith('bc1p') || address.startsWith('tb1p')) {
+      return 'taproot';
+    }
+    if (address.startsWith('3') || address.startsWith('2')) {
+      return 'nested-segwit';
+    }
+    return 'legacy';
+  }
+
+  protected handleError(error: unknown): never {
+    console.error('Exception in connector', this.id, error);
+    // Throw raw error for other cases
+    throw error;
+  }
+  // Abstract methods that must be implemented
+  abstract connect(network?: BitcoinNetwork): Promise<WalletAccount>;
+  abstract disconnect(): Promise<void>;
+  abstract getAccounts(): Promise<WalletAccount[]>;
+  abstract signMessage(message: string): Promise<string>;
+  abstract signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string>;
+  abstract sendTransaction(to: string, satoshis: number): Promise<string>;
+  abstract getNetwork(): Promise<BitcoinNetwork>;
+
+  // Optional methods - can be overridden
+  signPsbts?(
+    psbtHexs: string[],
+    options?: SignPsbtOptions
+  ): Promise<string[]>;
+
+  switchNetwork?(network: BitcoinNetwork): Promise<void>;
+
+  /**
+   * Subscribe to account changes
+   */
+  onAccountsChanged(callback: (accounts: WalletAccount[]) => void): () => void {
+    this._accountsChangedCallbacks.add(callback);
+    return () => {
+      this._accountsChangedCallbacks.delete(callback);
+    };
+  }
+
+  /**
+   * Subscribe to network changes
+   */
+  onNetworkChanged(callback: (network: BitcoinNetwork) => void): () => void {
+    this._networkChangedCallbacks.add(callback);
+    return () => {
+      this._networkChangedCallbacks.delete(callback);
+    };
+  }
+
+  /**
+   * Emit account change event
+   */
+  protected emitAccountsChanged(accounts: WalletAccount[]): void {
+    for (const callback of this._accountsChangedCallbacks) {
+      callback(accounts);
+    }
+  }
+
+  /**
+   * Emit network change event
+   */
+  protected emitNetworkChanged(network: BitcoinNetwork): void {
+    for (const callback of this._networkChangedCallbacks) {
+      callback(network);
+    }
+  }
+
+  /**
+   * Clean up all listeners
+   */
+  protected cleanup(): void {
+    this._accountsChangedCallbacks.clear();
+    this._networkChangedCallbacks.clear();
+  }
+}

package/src/binance/BinanceConnector.ts

@@ -0,0 +1,307 @@
+import type {
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+} from 'otx-btc-wallet-core';
+import { BaseConnector } from '../base';
+
+/**
+ * Binance sign PSBT options
+ * @see https://developers.binance.com/docs/binance-w3w/bitcoin-provider
+ */
+interface BinanceSignPsbtOptions {
+  autoFinalized?: boolean;
+  toSignInputs?: Array<{
+    index: number;
+    address?: string;
+    publicKey?: string;
+    sighashTypes?: number[];
+    disableTweakSigner?: boolean;
+  }>;
+}
+
+/**
+ * Binance Bitcoin provider interface
+ * Provider is accessible via window.binancew3w.bitcoin
+ * @see https://developers.binance.com/docs/binance-w3w/bitcoin-provider
+ */
+interface BinanceBitcoinProvider {
+  requestAccounts(): Promise<string[]>;
+  getAccounts(): Promise<string[]>;
+  getPublicKey(): Promise<string>;
+  getBalance(): Promise<{ confirmed: number; unconfirmed: number; total: number }>;
+  getNetwork(): Promise<string>;
+  switchNetwork(network: 'livenet' | 'testnet' | 'signet'): Promise<boolean>;
+  signMessage(msg: string, type?: 'ecdsa' | 'bip322-simple'): Promise<string>;
+  signPsbt(psbtHex: string, options?: BinanceSignPsbtOptions): Promise<string>;
+  signPsbts(psbtHexs: string[], options?: BinanceSignPsbtOptions[]): Promise<string[]>;
+  pushPsbt(psbtHex: string): Promise<string>;
+  sendBitcoin(toAddress: string, satoshis: number, options?: { feeRate?: number }): Promise<string>;
+  on(event: 'accountsChanged', callback: (accounts: string[]) => void): void;
+  on(event: 'networkChanged', callback: (network: string) => void): void;
+  removeListener(event: 'accountsChanged', callback: (accounts: string[]) => void): void;
+  removeListener(event: 'networkChanged', callback: (network: string) => void): void;
+}
+
+// Extend window type
+declare global {
+  interface Window {
+    binancew3w?: {
+      bitcoin?: BinanceBitcoinProvider;
+    };
+  }
+}
+
+// Binance wallet icon
+const BINANCE_ICON =
+  'data:image/jpeg;base64,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';
+
+/**
+ * Binance network type
+ */
+type BinanceNetwork = 'livenet' | 'testnet' | 'signet';
+
+/**
+ * Binance Wallet Connector
+ *
+ * @see https://developers.binance.com/docs/binance-w3w/bitcoin-provider
+ */
+export class BinanceConnector extends BaseConnector {
+  readonly id = 'binance';
+  readonly name = 'Binance Wallet';
+  readonly icon = BINANCE_ICON;
+
+  private _removeAccountChangeListener: (() => void) | null = null;
+  private _removeNetworkChangeListener: (() => void) | null = null;
+
+  protected getProvider(): BinanceBitcoinProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return window.binancew3w?.bitcoin;
+  }
+
+  async connect(network: BitcoinNetwork = 'mainnet'): Promise<WalletAccount> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const accounts = await provider.requestAccounts();
+      if (!accounts || accounts.length === 0) {
+        throw new Error('No accounts found');
+      }
+
+      // Switch network if needed
+      await this.ensureNetwork(provider, network);
+
+      const publicKey = await provider.getPublicKey();
+
+      // Setup event listeners
+      this.setupEventListeners();
+
+      return {
+        address: accounts[0] ?? '',
+        publicKey,
+        type: this.inferAddressType(accounts[0] ?? ''),
+      };
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private async ensureNetwork(provider: BinanceBitcoinProvider, network: BitcoinNetwork): Promise<void> {
+    const currentNetwork = await provider.getNetwork();
+    const targetNetwork = this.mapToBinanceNetwork(network);
+
+    if (currentNetwork !== targetNetwork) {
+      await provider.switchNetwork(targetNetwork);
+    }
+  }
+
+  private setupEventListeners(): void {
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    // Remove existing listeners
+    this.removeEventListeners();
+
+    // Account change listener
+    const handleAccountsChanged = (accounts: string[]) => {
+      if (!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(() => {
+        this.emitAccountsChanged([]);
+      });
+    };
+
+    // Network change listener
+    const handleNetworkChanged = (network: string) => {
+      const btcNetwork = this.mapNetwork(network);
+      this.emitNetworkChanged(btcNetwork);
+    };
+
+    provider.on('accountsChanged', handleAccountsChanged);
+    provider.on('networkChanged', handleNetworkChanged);
+
+    this._removeAccountChangeListener = () => {
+      provider.removeListener('accountsChanged', handleAccountsChanged);
+    };
+    this._removeNetworkChangeListener = () => {
+      provider.removeListener('networkChanged', handleNetworkChanged);
+    };
+  }
+
+  private removeEventListeners(): void {
+    this._removeAccountChangeListener?.();
+    this._removeAccountChangeListener = null;
+
+    this._removeNetworkChangeListener?.();
+    this._removeNetworkChangeListener = null;
+  }
+
+  async disconnect(): Promise<void> {
+    this.removeEventListeners();
+    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 binanceOptions: BinanceSignPsbtOptions = {
+        autoFinalized: options?.autoFinalize ?? true,
+      };
+
+      if (options?.toSignInputs) {
+        binanceOptions.toSignInputs = options.toSignInputs;
+      }
+
+      return await provider.signPsbt(psbtHex, binanceOptions);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbts(psbtHexs: string[], options?: SignPsbtOptions): Promise<string[]> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const binanceOptions: BinanceSignPsbtOptions = {
+        autoFinalized: options?.autoFinalize ?? true,
+      };
+
+      if (options?.toSignInputs) {
+        binanceOptions.toSignInputs = options.toSignInputs;
+      }
+
+      // Create options array for each PSBT
+      const optionsArray = psbtHexs.map(() => binanceOptions);
+
+      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 binanceNetwork = this.mapToBinanceNetwork(network);
+      await provider.switchNetwork(binanceNetwork);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private mapNetwork(network: string): BitcoinNetwork {
+    switch (network.toLowerCase()) {
+      case 'livenet':
+      case 'mainnet':
+        return 'mainnet';
+      case 'testnet':
+        return 'testnet';
+      case 'signet':
+        return 'signet';
+      default:
+        return 'mainnet';
+    }
+  }
+
+  private mapToBinanceNetwork(network: BitcoinNetwork): BinanceNetwork {
+    switch (network) {
+      case 'mainnet':
+        return 'livenet';
+      case 'testnet':
+      case 'testnet4':
+        return 'testnet';
+      case 'signet':
+        return 'signet';
+      default:
+        return 'livenet';
+    }
+  }
+}

package/src/binance/index.ts

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