otx-btc-wallet-connectors 0.1.0

package/src/bitget/BitgetConnector.ts

@@ -0,0 +1,301 @@
+import type {
+  WalletAccount,
+  BitcoinNetwork,
+  SignPsbtOptions,
+} from 'otx-btc-wallet-core';
+import { BaseConnector } from '../base';
+
+/**
+ * Bitget sign PSBT options
+ * @see https://web3.bitget.com/en/docs/connect/mainnet/btc/
+ */
+interface BitgetSignPsbtOptions {
+  autoFinalized?: boolean;
+  toSignInputs?: Array<{
+    index: number;
+    address?: string;
+    publicKey?: string;
+    sighashTypes?: number[];
+    disableTweakSigner?: boolean;
+  }>;
+}
+
+/**
+ * Bitget Bitcoin provider interface
+ * Provider is accessible via window.bitkeep.unisat
+ * @see https://web3.bitget.com/en/docs/connect/mainnet/btc/
+ */
+interface BitgetBitcoinProvider {
+  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<void>;
+  signMessage(msg: string, type?: 'ecdsa' | 'bip322-simple'): Promise<string>;
+  signPsbt(psbtHex: string, options?: BitgetSignPsbtOptions): Promise<string>;
+  signPsbts(psbtHexs: string[], options?: BitgetSignPsbtOptions[]): Promise<string[]>;
+  pushPsbt(psbtHex: string): Promise<string>;
+  sendBitcoin(toAddress: string, satoshis: number, options?: { feeRate?: number }): Promise<string>;
+  pushTx(options: { rawtx: string }): 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 {
+    bitkeep?: {
+      unisat?: BitgetBitcoinProvider;
+    };
+  }
+}
+
+// Bitget wallet icon
+const BITGET_ICON =
+  'data:image/svg+xml;base64,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';
+
+/**
+ * Bitget network type
+ */
+type BitgetNetwork = 'livenet' | 'testnet' | 'signet';
+
+/**
+ * Bitget Wallet Connector
+ *
+ * @see https://web3.bitget.com/en/docs/connect/mainnet/btc/
+ */
+export class BitgetConnector extends BaseConnector {
+  readonly id = 'bitget';
+  readonly name = 'Bitget Wallet';
+  readonly icon = BITGET_ICON;
+
+  private _removeAccountChangeListener: (() => void) | null = null;
+  private _removeNetworkChangeListener: (() => void) | null = null;
+
+  protected getProvider(): BitgetBitcoinProvider | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return window.bitkeep?.unisat;
+  }
+
+  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: BitgetBitcoinProvider, network: BitcoinNetwork): Promise<void> {
+    const currentNetwork = await provider.getNetwork();
+    const targetNetwork = this.mapToBitgetNetwork(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 {
+      // Bitget uses same API as Unisat - pass options directly if provided
+      return await provider.signPsbt(psbtHex, options);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async signPsbts(psbtHexs: string[], options?: SignPsbtOptions): Promise<string[]> {
+    this.ensureInstalled();
+    const provider = this.getProvider()!;
+
+    try {
+      const bitgetOptions: BitgetSignPsbtOptions = {
+        autoFinalized: options?.autoFinalize ?? true,
+      };
+
+      if (options?.toSignInputs) {
+        bitgetOptions.toSignInputs = options.toSignInputs;
+      }
+
+      // Create options array for each PSBT
+      const optionsArray = psbtHexs.map(() => bitgetOptions);
+
+      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 bitgetNetwork = this.mapToBitgetNetwork(network);
+      await provider.switchNetwork(bitgetNetwork);
+    } 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 mapToBitgetNetwork(network: BitcoinNetwork): BitgetNetwork {
+    switch (network) {
+      case 'mainnet':
+        return 'livenet';
+      case 'testnet':
+      case 'testnet4':
+        return 'testnet';
+      case 'signet':
+        return 'signet';
+      default:
+        return 'livenet';
+    }
+  }
+}

package/src/bitget/index.ts

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