otx-btc-wallet-connectors 0.1.0

package/src/imtoken/ImTokenConnector.ts

@@ -0,0 +1,420 @@
+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 ImTokenSendOptions extends GeneratePsbtOptions {
+  // Additional imToken-specific options can be added here
+}
+
+/**
+ * imToken Bitcoin provider interface
+ * Provider is accessible via window.bitcoin
+ * @see https://imtoken.gitbook.io/developers/products/webview/bitcoin
+ */
+interface ImTokenBitcoinProvider {
+  request(params: { method: 'btc_requestAccounts' }): Promise<string[]>;
+  request(params: { method: 'btc_getNetwork' }): Promise<string>;
+  request(params: { method: 'btc_getPublicKey' }): Promise<string>;
+  request(params: { method: 'btc_getBalance'; params: [string] }): Promise<number>;
+  request(params: { method: 'btc_signPsbt'; params: [string, boolean?] }): Promise<string>;
+  request(params: { method: 'btc_signPsbts'; params: [string[]] }): Promise<string[]>;
+  request(params: {
+    method: 'btc_signMessage';
+    params: [string, 'bip322-simple' | 'bip322-full' | 'bip322-legacy'];
+  }): Promise<string>;
+  request(params: { method: 'btc_sendRawTransaction'; params: [string] }): Promise<string>;
+  request(params: { method: 'btc_switchNetwork'; params: [string] }): Promise<null>;
+  on(event: 'accountsChanged', callback: (...args: unknown[]) => void): void;
+  on(event: 'networkChanged', callback: (...args: unknown[]) => void): void;
+  removeListener(event: string, callback: (...args: unknown[]) => void): void;
+}
+
+// Extend window type
+declare global {
+  interface Window {
+    bitcoin?: ImTokenBitcoinProvider;
+  }
+}
+
+// imToken wallet icon
+const IMTOKEN_ICON =
+  'data:image/svg+xml;base64,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';
+
+/**
+ * imToken network type
+ */
+type ImTokenNetwork = 'mainnet' | 'signet';
+
+/**
+ * imToken Wallet Connector
+ *
+ * @see https://imtoken.gitbook.io/developers/products/webview/bitcoin
+ */
+export class ImTokenConnector extends BaseConnector {
+  readonly id = 'imtoken';
+  readonly name = 'imToken';
+  readonly icon = IMTOKEN_ICON;
+  readonly downloadUrl = 'https://token.im/download';
+
+  private _publicKey: string | null = null;
+  private _address: string | null = null;
+  private _network: BitcoinNetwork = 'mainnet';
+  private _removeAccountChangeListener: (() => void) | null = null;
+  private _removeNetworkChangeListener: (() => void) | null = null;
+
+  protected getProvider(): ImTokenBitcoinProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return window.bitcoin;
+  }
+
+  async connect(network: BitcoinNetwork = 'mainnet'): Promise<WalletAccount> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      // Switch network first (may not be supported yet)
+      await this.trySwitchNetwork(provider, network);
+
+      // Request accounts
+      const accounts = await provider.request({ method: 'btc_requestAccounts' });
+      if (!accounts || accounts.length === 0) {
+        throw new Error('No accounts found');
+      }
+
+      // Get public key
+      this._publicKey = await provider.request({ method: 'btc_getPublicKey' });
+      this._address = accounts[0] ?? '';
+      this._network = network;
+
+      // Setup event listeners
+      this.setupEventListeners();
+
+      return {
+        address: this._address,
+        publicKey: this._publicKey,
+        type: this.inferAddressType(this._address),
+      };
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private async trySwitchNetwork(
+    provider: ImTokenBitcoinProvider,
+    network: BitcoinNetwork
+  ): Promise<void> {
+    try {
+      const imTokenNetwork = this.mapToImTokenNetwork(network);
+      await provider.request({ method: 'btc_switchNetwork', params: [imTokenNetwork] });
+    } catch {
+      // Network switching might not be supported yet, continue with current network
+      console.warn('imToken network switching may not be supported');
+    }
+  }
+
+  private setupEventListeners(): void {
+    const provider = this.getProvider();
+    if (!provider || typeof provider.on !== 'function') return;
+
+    // Remove existing listeners
+    this.removeEventListeners();
+
+    // Account change listener
+    const handleAccountsChanged = (...args: unknown[]) => {
+      const accounts = args[0] as string[];
+      if (!accounts || accounts.length === 0) {
+        this.emitAccountsChanged([]);
+        return;
+      }
+
+      provider
+        .request({ method: 'btc_getPublicKey' })
+        .then((publicKey) => {
+          this._publicKey = publicKey;
+          const walletAccounts: WalletAccount[] = accounts.map((address) => ({
+            address,
+            publicKey,
+            type: this.inferAddressType(address),
+          }));
+          this.emitAccountsChanged(walletAccounts);
+        })
+        .catch(() => {
+          this.emitAccountsChanged([]);
+        });
+    };
+
+    // Network change listener
+    const handleNetworkChanged = () => {
+      // When network changes, we need to re-fetch network info
+      provider
+        .request({ method: 'btc_getNetwork' })
+        .then((network) => {
+          const btcNetwork = this.mapNetwork(network);
+          this.emitNetworkChanged(btcNetwork);
+        })
+        .catch(() => {
+          // Ignore errors
+        });
+    };
+
+    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._publicKey = null;
+    this._address = null;
+    this.cleanup();
+  }
+
+  async getAccounts(): Promise<WalletAccount[]> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const addresses = await provider.request({ method: 'btc_requestAccounts' });
+      const publicKey = await provider.request({ method: 'btc_getPublicKey' });
+      this._publicKey = publicKey;
+
+      return addresses.map((address) => ({
+        address,
+        publicKey,
+        type: this.inferAddressType(address),
+      }));
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * Sign a message using BIP-322 simple format
+   * Note: Only bip322-simple is supported by imToken
+   */
+  async signMessage(message: string): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      return await provider.request({
+        method: 'btc_signMessage',
+        params: [message, 'bip322-simple'],
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const autoFinalize = options?.autoFinalize ?? true;
+      return await provider.request({
+        method: 'btc_signPsbt',
+        params: [psbtHex, autoFinalize],
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbts(psbtHexs: string[]): Promise<string[]> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      return await provider.request({
+        method: 'btc_signPsbts',
+        params: [psbtHexs],
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * Send Bitcoin transaction
+   * Builds a PSBT using bitcoinjs-lib, signs it with imToken, 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?: ImTokenSendOptions
+  ): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    if (!this._address || !this._publicKey) {
+      throw new Error('Not connected. Please call connect() first.');
+    }
+
+    const btcNetwork = getBitcoinJsNetwork(this._network);
+
+    // 1. Generate PSBT using the utility
+    const {
+      psbtHex,
+      selectedUtxos,
+    } = await generatePsbtForSend(
+      to,
+      satoshis,
+      this._address,
+      this._publicKey,
+      this._network,
+      options
+    );
+
+    // 2. Sign PSBT with imToken (autoFinalize = false to handle finalization ourselves)
+    const signedPsbtHex = await provider.request({
+      method: 'btc_signPsbt',
+      params: [psbtHex, false],
+    });
+
+    // 3. Parse signed PSBT and finalize
+    const signedPsbt = bitcoin.Psbt.fromHex(signedPsbtHex, { network: btcNetwork });
+    finalizeAllInputs(signedPsbt, selectedUtxos.length);
+
+    // 4. Extract transaction
+    const tx = signedPsbt.extractTransaction();
+    const txHex = tx.toHex();
+
+    // 5. Broadcast using imToken or fallback to BtcService
+    try {
+      const txid = await provider.request({
+        method: 'btc_sendRawTransaction',
+        params: [txHex],
+      });
+      return txid;
+    } catch {
+      // Fallback to BtcService broadcast
+      const btcService = new BtcService(this._network);
+      return await btcService.broadcastTransaction(txHex);
+    }
+  }
+
+  /**
+   * Broadcast a raw transaction
+   */
+  async broadcastTransaction(txHex: string): Promise<string> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      return await provider.request({
+        method: 'btc_sendRawTransaction',
+        params: [txHex],
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async getNetwork(): Promise<BitcoinNetwork> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const network = await provider.request({ method: 'btc_getNetwork' });
+      return this.mapNetwork(network);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async switchNetwork(network: BitcoinNetwork): Promise<void> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const imTokenNetwork = this.mapToImTokenNetwork(network);
+      await provider.request({ method: 'btc_switchNetwork', params: [imTokenNetwork] });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * Get the public key (cached from connect)
+   */
+  getPublicKey(): string | null {
+    return this._publicKey;
+  }
+
+  /**
+   * Get balance for an address
+   */
+  async getBalance(address: string): Promise<number> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      return await provider.request({
+        method: 'btc_getBalance',
+        params: [address],
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  private mapNetwork(network: string): BitcoinNetwork {
+    switch (network.toLowerCase()) {
+      case 'mainnet':
+        return 'mainnet';
+      case 'signet':
+        return 'signet';
+      case 'testnet':
+        return 'testnet';
+      default:
+        return 'mainnet';
+    }
+  }
+
+  private mapToImTokenNetwork(network: BitcoinNetwork): ImTokenNetwork {
+    switch (network) {
+      case 'mainnet':
+        return 'mainnet';
+      case 'signet':
+      case 'testnet':
+      case 'testnet4':
+        return 'signet';
+      default:
+        return 'mainnet';
+    }
+  }
+}

package/src/imtoken/index.ts

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

package/src/index.ts

@@ -0,0 +1,78 @@
+// otx-btc-wallet-connectors - Bitcoin wallet connectors
+
+// Base
+export { BaseConnector } from './base';
+
+// Connectors
+export { UnisatConnector } from './unisat';
+export { XverseConnector } from './xverse';
+export { OKXConnector } from './okx';
+export { PhantomConnector } from './phantom';
+export type { PhantomSendOptions } from './phantom';
+export { BitgetConnector } from './bitget';
+export { BinanceConnector } from './binance';
+export { LedgerConnector } from './ledger';
+export type {
+  LedgerConnectorOptions,
+  LedgerAddressType,
+  LedgerUtxoInput,
+  LedgerTxOutput,
+  SendBitcoinOptions,
+} from './ledger';
+export { TrezorConnector } from './trezor';
+export type {
+  TrezorConnectorOptions,
+  TrezorAddressType,
+  TrezorSendBitcoinOptions,
+} from './trezor';
+export { ImTokenConnector } from './imtoken';
+export type { ImTokenSendOptions } from './imtoken';
+
+// Bitcoin Services & Utilities
+export {
+  MempoolService,
+  BlockstreamService,
+  BtcService,
+  // Configuration
+  configureBtcService,
+  getBtcServiceConfig,
+  // Standalone functions
+  getUtxos,
+  getUtxosWithTxHex,
+  getTxHex,
+  getTransaction,
+  getFullTransaction,
+  broadcastTransaction,
+  getAddressInfo,
+  getBalance,
+  getConfirmedBalance,
+  getFeeRates,
+  // PSBT utilities
+  generatePsbtForSend,
+  finalizeAllInputs,
+  finalizeAndBroadcast,
+  selectUtxos,
+  hexToBytes,
+  bytesToHex,
+  toXOnly,
+  getAddressType,
+  getBitcoinJsNetwork,
+  getInputVBytes,
+  getOutputVBytes,
+  getDustThreshold,
+  deriveAddressFromPublicKey,
+} from './utils';
+
+export type {
+  Utxo,
+  UtxoWithTx,
+  FeeRates,
+  Transaction,
+  FullTransaction,
+  AddressBalance,
+  IBtcService,
+  BtcServiceConfig,
+  NetworkEndpoints,
+  GeneratePsbtOptions,
+  GeneratePsbtResult,
+} from './utils';