bitcoin-wallet-connector 0.1.0

package/src/react.ts

@@ -0,0 +1,9 @@
+export {
+  BitcoinConnectionProvider,
+  useBitcoinConnectionContext,
+} from "./BitcoinConnectionProvider"
+
+export type {
+  WalletSession,
+  BitcoinConnectionContextValue,
+} from "./BitcoinConnectionProvider"

package/src/utils/StateChannel.ts

@@ -0,0 +1,39 @@
+export type StateChannelListener<T> = (value: T) => void
+
+export interface StateChannelSubscription {
+  unsubscribe: () => void
+}
+
+export class StateChannel<T> {
+  private listeners = new Set<StateChannelListener<T>>()
+  constructor(private value: T) {}
+
+  getValue(): T {
+    return this.value
+  }
+
+  setValue(value: T): void {
+    this.value = value
+    this.emit()
+  }
+
+  update(updater: (current: T) => T): void {
+    this.setValue(updater(this.value))
+  }
+
+  subscribe(listener: StateChannelListener<T>): StateChannelSubscription {
+    this.listeners.add(listener)
+    listener(this.value)
+    return {
+      unsubscribe: () => {
+        this.listeners.delete(listener)
+      },
+    }
+  }
+
+  private emit(): void {
+    for (const listener of this.listeners) {
+      listener(this.value)
+    }
+  }
+}

package/src/utils/UnisatCompatibleWalletAdapterImpl.ts

@@ -0,0 +1,342 @@
+import { hex } from "@scure/base"
+import * as btc from "@scure/btc-signer"
+import { hasAny } from "./misc"
+import {
+  addressToScriptPubKey,
+  getAddressType,
+  getRedeemScriptOf_P2SH_P2WPKH_publicKey,
+  getTapInternalKeyOf_P2TR_publicKey,
+} from "./bitcoinAddressHelpers"
+import { getBitcoinNetwork } from "./bitcoinNetworkHelpers"
+import { UserRejectError, BitcoinWalletAdapterError } from "../utils/error"
+import {
+  SignMessageAlgorithm,
+  SignMessageResult,
+  WalletAdapter,
+  WalletAdapter_onAddressesChanged_callback,
+  WalletAdapterAddress,
+  WalletAdapterAddressPurpose,
+  WalletAdapterAddressType,
+  WalletAdapterBitcoinNetwork,
+  WalletAdapterNotConnectedError,
+} from "../WalletAdapters.types"
+
+/**
+ * https://docs.unisat.io/dev-center/open-api-documentation/unisat-wallet#events
+ */
+export interface UniSatEvents {
+  accountsChanged: [accounts: Array<string>]
+  networkChanged: [network: string]
+}
+
+export interface UnisatCompatibleProviderAPI {
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#getaccounts
+   */
+  getAccounts(): Promise<string[]>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#requestaccounts
+   */
+  requestAccounts(): Promise<string[]>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#getpublickey
+   */
+  getPublicKey(): Promise<string>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#getnetwork
+   */
+  getNetwork(): Promise<"livenet" | "testnet">
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#signmessage
+   */
+  signMessage(
+    message: string,
+    algorithm: "ecdsa" | "bip322-simple",
+  ): Promise<string>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#sendbitcoin
+   */
+  sendBitcoin(
+    receiverAddress: string,
+    satoshiAmount: number,
+    options?: { feeRate?: number },
+  ): Promise<string>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#sendInscription
+   */
+  sendInscription(
+    receiverAddress: string,
+    inscriptionId: string,
+    options?: { feeRate?: number },
+  ): Promise<string>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#signpsbt
+   */
+  signPsbt(
+    psbtHex: string,
+    options?: {
+      autoFinalized?: boolean
+      toSignInputs?: {
+        index: number
+        address?: string
+        publicKey?: string
+        sighashTypes?: number[]
+        disableTweakSigner?: boolean
+      }[]
+    },
+  ): Promise<string>
+
+  /**
+   * https://docs.unisat.io/dev/unisat-developer-service/unisat-wallet#events
+   */
+  on<K extends keyof UniSatEvents>(
+    event: K,
+    handler: (...args: UniSatEvents[K]) => void,
+  ): void
+  removeListener(event: keyof UniSatEvents, handler: () => void): void
+}
+
+export type UnisatCompatibleWalletAdapterAddresses = (WalletAdapterAddress & {
+  publicKey: string
+})[]
+
+export class UnisatCompatibleWalletAdapterImpl implements WalletAdapter {
+  constructor(
+    private unisat: UnisatCompatibleProviderAPI,
+    private walletDisplayName: string,
+  ) {}
+
+  async connect(): Promise<void> {
+    if ((await this.unisat.getAccounts()).length === 0) {
+      await this.unisat.requestAccounts()
+    }
+  }
+
+  disconnect(): Promise<void> {
+    // do nothing
+    return Promise.resolve()
+  }
+
+  async getAddresses(): Promise<UnisatCompatibleWalletAdapterAddresses> {
+    const addresses: string[] = await this.unisat.getAccounts()
+
+    if (addresses.length === 0) {
+      throw new WalletAdapterNotConnectedError(this.walletDisplayName)
+    }
+
+    const publicKey: string = await this.unisat.getPublicKey()
+
+    const _network: "livenet" | "testnet" = await this.unisat.getNetwork()
+    const network = _network === "livenet" ? "mainnet" : "testnet"
+
+    if (!hasAny(addresses)) {
+      throw new BitcoinWalletAdapterError("Request wallet addresses failed")
+    }
+
+    const address = addresses[0]
+    const addrType = getAddressType(getBitcoinNetwork(network), address)
+    // prettier-ignore
+    const addressType =
+      addrType === "p2tr" ? WalletAdapterAddressType.P2TR :
+      addrType === "p2sh" ? WalletAdapterAddressType.P2SH_P2WPKH :
+      addrType === "p2wpkh" ? WalletAdapterAddressType.P2WPKH :
+      undefined
+
+    if (addressType == null) {
+      throw new BitcoinWalletAdapterError("Please select a SegWit address")
+    }
+
+    const scriptPubKey = hex.encode(
+      addressToScriptPubKey(getBitcoinNetwork(network), address),
+    )
+
+    const tapInternalKey =
+      addressType !== WalletAdapterAddressType.P2TR
+        ? undefined
+        : hex.encode(
+            getTapInternalKeyOf_P2TR_publicKey(
+              getBitcoinNetwork(network),
+              hex.decode(publicKey),
+            ),
+          )
+
+    const redeemScript =
+      addressType !== WalletAdapterAddressType.P2SH_P2WPKH
+        ? undefined
+        : hex.encode(
+            getRedeemScriptOf_P2SH_P2WPKH_publicKey(
+              getBitcoinNetwork(network),
+              hex.decode(publicKey),
+            ),
+          )
+
+    return [
+      {
+        addressType,
+        address,
+        scriptPubKey,
+        redeemScript,
+        tapInternalKey,
+        publicKey,
+        network:
+          network === "mainnet"
+            ? WalletAdapterBitcoinNetwork.MAINNET
+            : WalletAdapterBitcoinNetwork.TESTNET,
+        purposes: [
+          WalletAdapterAddressPurpose.Bitcoin,
+          WalletAdapterAddressPurpose.Ordinals,
+          WalletAdapterAddressPurpose.BRC20,
+          WalletAdapterAddressPurpose.Runes,
+        ],
+      },
+    ]
+  }
+
+  async signMessage(
+    address: string,
+    message: string,
+  ): Promise<SignMessageResult> {
+    const result = await handleRpcError(
+      this.unisat.signMessage(message, "bip322-simple"),
+    )
+
+    return {
+      result,
+      address,
+      algorithm: SignMessageAlgorithm.BIP322,
+    }
+  }
+
+  sendBitcoinFeeRateCapability: WalletAdapter["sendBitcoinFeeRateCapability"] =
+    "available" as const
+  async sendBitcoin(
+    fromAddress: string,
+    receiverAddress: string,
+    satoshiAmount: bigint,
+    options?: { feeRate?: number },
+  ): Promise<{ txid: string }> {
+    const txid = await handleRpcError(
+      this.unisat.sendBitcoin(receiverAddress, Number(satoshiAmount), {
+        feeRate: options?.feeRate,
+      }),
+    )
+    return { txid }
+  }
+
+  sendInscriptionFeeRateCapability: WalletAdapter["sendInscriptionFeeRateCapability"] =
+    "available" as const
+  async sendInscription(
+    fromAddress: string,
+    receiverAddress: string,
+    inscriptionId: string,
+    options?: { feeRate?: number },
+  ): Promise<{ txid: string }> {
+    const txid = await handleRpcError(
+      this.unisat.sendInscription(receiverAddress, inscriptionId, {
+        feeRate: options?.feeRate,
+      }),
+    )
+    return { txid }
+  }
+
+  async signAndFinalizePsbt(
+    psbtHex: string,
+    signIndices: [address: string, signIndex: number][],
+  ): Promise<{
+    signedPsbtHex: string
+  }> {
+    const addr = await this.getAddresses()
+
+    const signedPsbtHex = await handleRpcError(
+      this.unisat.signPsbt(psbtHex, {
+        autoFinalized: false,
+        toSignInputs: signIndices.map(([address, signIndex]) => ({
+          index: signIndex,
+          address,
+        })),
+      }),
+    )
+
+    /**
+     * Some version of unisat's signPsbt API does not working well with the autoFinalized option,
+     * so we finalize the PSBT manually.
+     */
+    const tx = btc.Transaction.fromPSBT(hex.decode(signedPsbtHex), {
+      allowUnknownInputs: true,
+      allowUnknownOutputs: true,
+      disableScriptCheck: true,
+      allowLegacyWitnessUtxo: true,
+    })
+    tx.finalize()
+
+    return { signedPsbtHex: hex.encode(tx.toPSBT()) }
+  }
+
+  onAddressesChanged(callback: WalletAdapter_onAddressesChanged_callback): {
+    unsubscribe: () => void
+  } {
+    const handler = async (): Promise<void> => {
+      try {
+        const addresses = await this.getAddresses()
+        callback({ addresses })
+      } catch (error) {
+        // Ignore errors from getAddresses (e.g., wallet disconnected)
+        console.warn(
+          `[${this.walletDisplayName}] Failed to get addresses on change:`,
+          error,
+        )
+      }
+    }
+
+    // Listen to both account and network changes
+    this.unisat.on("accountsChanged", handler)
+    this.unisat.on("networkChanged", handler)
+
+    return {
+      unsubscribe: () => {
+        this.unisat.removeListener("accountsChanged", handler)
+        this.unisat.removeListener("networkChanged", handler)
+      },
+    }
+  }
+}
+
+interface UnisatCompatibleProviderAPIThrownError {
+  code: number
+  message: string
+}
+function isUnisatCompatibleProviderAPIThrownError(
+  err: any,
+): err is UnisatCompatibleProviderAPIThrownError {
+  return err != null && "code" in err && "message" in err
+}
+
+export class UnisatCompatibleProviderError extends Error {
+  readonly code: number
+  constructor(err: UnisatCompatibleProviderAPIThrownError) {
+    super(err.message)
+    this.code = err.code
+    this.cause = err
+  }
+}
+
+const handleRpcError = async <T>(promise: Promise<T>): Promise<T> => {
+  try {
+    return await promise
+  } catch (e: any) {
+    if (isUnisatCompatibleProviderAPIThrownError(e)) {
+      if (e.code === 4001) {
+        throw new UserRejectError()
+      }
+      throw new UnisatCompatibleProviderError(e)
+    }
+    throw e
+  }
+}

package/src/utils/XverseCompatibleWalletAdapterImpl.ts

@@ -0,0 +1,288 @@
+import { base64, hex } from "@scure/base"
+import * as btc from "@scure/btc-signer"
+import { UserRejectError } from "../utils/error"
+import {
+  SignMessageAlgorithm,
+  SignMessageResult,
+  WalletAdapter,
+  WalletAdapter_onAddressesChanged_callback,
+  WalletAdapterAddress,
+  WalletAdapterAddressPurpose,
+  WalletAdapterNotConnectedError,
+} from "../WalletAdapters.types"
+
+export type XverseCompatibleWalletAdapterGetProviderIdFn = () => Promise<string>
+
+export type XverseCompatibleWalletAdapterParsedAddressesFn = (info: {
+  sdk: typeof import("sats-connect")
+  network: import("sats-connect").BitcoinNetworkType
+  addresses: import("sats-connect").Address[]
+}) => Promise<XverseCompatibleWalletAdapterImplAddress[]>
+
+export type XverseCompatibleWalletAdapterImplAddress = WalletAdapterAddress & {
+  publicKey: string
+}
+
+export class XverseCompatibleWalletAdapterImpl implements WalletAdapter {
+  protected readonly walletDisplayName: string
+  protected readonly getProviderId: XverseCompatibleWalletAdapterGetProviderIdFn
+  protected readonly parseAddresses: XverseCompatibleWalletAdapterParsedAddressesFn
+
+  constructor(info: {
+    walletDisplayName: string
+    getProviderId: XverseCompatibleWalletAdapterGetProviderIdFn
+    parseAddresses: XverseCompatibleWalletAdapterParsedAddressesFn
+  }) {
+    this.walletDisplayName = info.walletDisplayName
+    this.getProviderId = info.getProviderId
+    this.parseAddresses = info.parseAddresses
+  }
+
+  private async getSdk(): Promise<typeof import("sats-connect")> {
+    return import("sats-connect")
+  }
+
+  async connect(): Promise<void> {
+    await (await this.getSdk()).request("wallet_connect", null)
+  }
+
+  async disconnect(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  async getAddresses(): Promise<XverseCompatibleWalletAdapterImplAddress[]> {
+    const sdk = await this.getSdk()
+
+    const resp = await handleRpcError(
+      sdk.request(
+        "getAddresses",
+        {
+          purposes: [sdk.AddressPurpose.Ordinals, sdk.AddressPurpose.Payment],
+        },
+        await this.getProviderId(),
+      ),
+    )
+
+    if (resp == null) {
+      throw new WalletAdapterNotConnectedError(this.walletDisplayName)
+    }
+
+    return this.parseAddresses({
+      sdk,
+      network: resp.network.bitcoin.name,
+      addresses: resp.addresses,
+    })
+  }
+
+  async signMessage(
+    address: string,
+    message: string,
+  ): Promise<SignMessageResult> {
+    const sdk = await this.getSdk()
+
+    const result = await handleRpcError(
+      sdk.request(
+        "signMessage",
+        {
+          address,
+          message,
+          protocol: sdk.MessageSigningProtocols.BIP322,
+        },
+        await this.getProviderId(),
+      ),
+    )
+
+    return {
+      result: result.signature,
+      address,
+      algorithm: SignMessageAlgorithm.BIP322,
+    }
+  }
+
+  sendBitcoinFeeRateCapability = "unavailable" as const
+  async sendBitcoin(
+    fromAddress: string,
+    receiverAddress: string,
+    satoshiAmount: bigint,
+  ): Promise<{ txid: string }> {
+    const senderAddress = (await this.getAddresses()).find(a =>
+      a.purposes.includes(WalletAdapterAddressPurpose.Bitcoin),
+    )
+    if (senderAddress == null) {
+      throw new XverseCompatibleProviderError({
+        code: XverseRpcErrorCode.INVALID_PARAMS,
+        message: "Bitcoin address not found",
+      })
+    }
+
+    const sdk = await this.getSdk()
+
+    return await handleRpcError(
+      sdk.request(
+        "sendTransfer",
+        {
+          recipients: [
+            {
+              address: receiverAddress,
+              amount: Number(satoshiAmount),
+            },
+          ],
+        },
+        await this.getProviderId(),
+      ),
+    )
+  }
+
+  sendInscriptionFeeRateCapability = "unavailable" as const
+
+  async signAndFinalizePsbt(
+    psbtHex: string,
+    signIndices: [address: string, signIndex: number][],
+  ): Promise<{
+    signedPsbtHex: string
+  }> {
+    const sdk = await this.getSdk()
+
+    const psbtBase64 = base64.encode(hex.decode(psbtHex))
+
+    const result = await handleRpcError(
+      sdk.request(
+        "signPsbt",
+        {
+          psbt: psbtBase64,
+          signInputs: signIndices.reduce(
+            (acc, [address, signIndex]) => {
+              acc[address] = [signIndex]
+              return acc
+            },
+            {} as Record<string, number[]>,
+          ),
+          broadcast: false,
+        },
+        await this.getProviderId(),
+      ),
+    )
+
+    const tx = btc.Transaction.fromPSBT(base64.decode(result.psbt), {
+      allowUnknownInputs: true,
+      allowUnknownOutputs: true,
+      disableScriptCheck: true,
+      allowLegacyWitnessUtxo: true,
+    })
+    tx.finalize()
+
+    return { signedPsbtHex: hex.encode(tx.toPSBT()) }
+  }
+
+  onAddressesChanged(callback: WalletAdapter_onAddressesChanged_callback): {
+    unsubscribe: () => void
+  } {
+    // Xverse uses sats-connect Wallet.addListener for events
+    // https://docs.xverse.app/sats-connect/xverse-wallet-events
+    const removeListeners: Array<() => void> = []
+
+    void (async () => {
+      const sdk = await this.getSdk()
+
+      const handler = async (): Promise<void> => {
+        try {
+          const addresses = await this.getAddresses()
+          callback({ addresses })
+        } catch (error) {
+          console.warn(
+            `[${this.walletDisplayName}] Failed to get addresses on change:`,
+            error,
+          )
+        }
+      }
+
+      // Listen to account and network changes
+      const removeAccountListener = sdk.addListener("accountChange", handler)
+      const removeNetworkListener = sdk.addListener("networkChange", handler)
+
+      removeListeners.push(removeAccountListener, removeNetworkListener)
+    })()
+
+    return {
+      unsubscribe: () => {
+        removeListeners.forEach(remove => remove())
+      },
+    }
+  }
+}
+
+export enum XverseRpcErrorCode {
+  /**
+   * Parse error Invalid JSON
+   **/
+  PARSE_ERROR = -32700,
+  /**
+   * The JSON sent is not a valid Request object.
+   **/
+  INVALID_REQUEST = -32600,
+  /**
+   * The method does not exist/is not available.
+   **/
+  METHOD_NOT_FOUND = -32601,
+  /**
+   * Invalid method parameter(s).
+   */
+  INVALID_PARAMS = -32602,
+  /**
+   * Internal JSON-RPC error.
+   * This is a generic error, used when the server encounters an error in performing the request.
+   **/
+  INTERNAL_ERROR = -32603,
+  /**
+   * user rejected/canceled the request
+   */
+  USER_REJECTION = -32000,
+  /**
+   * method is not supported for the address provided
+   */
+  METHOD_NOT_SUPPORTED = -32001,
+  /**
+   * The client does not have permission to access the requested resource.
+   */
+  ACCESS_DENIED = -32002,
+}
+export interface XverseCompatibleProviderAPIThrownError {
+  code: XverseRpcErrorCode
+  message: string
+}
+export function isXverseCompatibleProviderAPIThrownError(
+  err: any,
+): err is XverseCompatibleProviderAPIThrownError {
+  return err != null && "code" in err && "message" in err
+}
+
+export class XverseCompatibleProviderError extends Error {
+  readonly code: number
+  constructor(err: XverseCompatibleProviderAPIThrownError) {
+    super(err.message)
+    this.code = err.code
+    this.cause = err
+  }
+}
+
+const handleRpcError = async <T>(
+  promise: Promise<
+    { status: "success"; result: T } | { status: "error"; error: unknown }
+  >,
+): Promise<T> => {
+  try {
+    const res = await promise
+    if (res.status === "error") {
+      throw res.error
+    }
+    return res.result
+  } catch (e: any) {
+    if (isXverseCompatibleProviderAPIThrownError(e)) {
+      if (e.code === XverseRpcErrorCode.USER_REJECTION) {
+        throw new UserRejectError()
+      }
+      throw new XverseCompatibleProviderError(e)
+    }
+    throw e
+  }
+}