bitcoin-wallet-connector 0.1.0

package/src/utils/XverseCompatibleWalletAdapterImpl_legacy.ts

@@ -0,0 +1,278 @@
+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,
+  WalletAdapterBitcoinNetwork,
+  WalletAdapterNotConnectedError,
+} from "../WalletAdapters.types"
+import {
+  XverseCompatibleProviderError,
+  XverseRpcErrorCode,
+} from "./XverseCompatibleWalletAdapterImpl"
+
+type GetAddressResponse = import("sats-connect").GetAddressResponse
+
+export type XverseCompatibleWalletAdapterGetProviderFn = () => Promise<
+  import("sats-connect").BitcoinProvider
+>
+
+export type XverseCompatibleWalletAdapterParsedAddressesFn = (info: {
+  sdk: typeof import("sats-connect")
+  addresses: import("sats-connect").Address[]
+}) => Promise<XverseCompatibleWalletAdapterImplAddress[]>
+
+export type XverseCompatibleWalletAdapterImplAddress = WalletAdapterAddress & {
+  publicKey: string
+}
+
+export class XverseCompatibleWalletAdapterImpl_legacy implements WalletAdapter {
+  protected readonly network: WalletAdapterBitcoinNetwork
+  protected readonly localStorageKey: string
+  protected readonly walletDisplayName: string
+  protected readonly getProvider: XverseCompatibleWalletAdapterGetProviderFn
+  protected readonly parseAddresses: XverseCompatibleWalletAdapterParsedAddressesFn
+
+  constructor(info: {
+    network: WalletAdapterBitcoinNetwork
+    localStorageKey: string
+    walletDisplayName: string
+    getProvider: XverseCompatibleWalletAdapterGetProviderFn
+    parseAddresses: XverseCompatibleWalletAdapterParsedAddressesFn
+  }) {
+    this.network = info.network
+    this.localStorageKey = info.localStorageKey
+    this.walletDisplayName = info.walletDisplayName
+    this.getProvider = info.getProvider
+    this.parseAddresses = info.parseAddresses
+  }
+
+  private async getSdk(): Promise<typeof import("sats-connect")> {
+    return import("sats-connect")
+  }
+
+  protected retrieveConnectedAddress(): GetAddressResponse | undefined {
+    let resp: GetAddressResponse | undefined
+    const stored = localStorage.getItem(this.localStorageKey) || undefined
+    if (stored != null) {
+      try {
+        resp = JSON.parse(stored)
+        if (
+          resp == null ||
+          !("addresses" in resp) ||
+          !Array.isArray(resp.addresses)
+        ) {
+          throw new Error("Invalid stored addresses")
+        }
+      } catch {
+        localStorage.removeItem(this.localStorageKey)
+      }
+    }
+    return resp
+  }
+  protected async updateConnectedAddress(
+    addresses: GetAddressResponse["addresses"],
+  ): Promise<void> {
+    localStorage.setItem(this.localStorageKey, JSON.stringify({ addresses }))
+  }
+
+  async connect(): Promise<void> {
+    if (this.retrieveConnectedAddress() == null) {
+      const resp = await this.connectImpl()
+      await this.updateConnectedAddress(resp.addresses)
+    }
+  }
+  private async connectImpl(): Promise<GetAddressResponse> {
+    const sdk = await this.getSdk()
+
+    const networkType =
+      this.network === WalletAdapterBitcoinNetwork.MAINNET
+        ? sdk.BitcoinNetworkType.Mainnet
+        : sdk.BitcoinNetworkType.Testnet
+
+    return new Promise<GetAddressResponse>((resolve, reject) => {
+      void sdk
+        .getAddress({
+          getProvider: () => this.getProvider(),
+          payload: {
+            purposes: [sdk.AddressPurpose.Ordinals, sdk.AddressPurpose.Payment],
+            message: "Address for receiving Ordinals and payments",
+            network: { type: networkType },
+          },
+          onFinish(resp) {
+            resolve(resp)
+          },
+          onCancel() {
+            reject(new UserRejectError())
+          },
+        })
+        .catch(reject)
+    })
+  }
+
+  async disconnect(): Promise<void> {
+    localStorage.removeItem(this.localStorageKey)
+    return Promise.resolve()
+  }
+
+  async getAddresses(): Promise<XverseCompatibleWalletAdapterImplAddress[]> {
+    const resp = this.retrieveConnectedAddress()
+
+    if (resp == null) {
+      throw new WalletAdapterNotConnectedError(this.walletDisplayName)
+    }
+
+    const sdk = await this.getSdk()
+
+    return this.parseAddresses({ sdk, addresses: resp.addresses })
+  }
+
+  async signMessage(
+    address: string,
+    message: string,
+  ): Promise<SignMessageResult> {
+    const sdk = await this.getSdk()
+
+    return new Promise((resolve, reject) => {
+      /**
+       * https://docs.xverse.app/sats-connect/methods/signmessage
+       */
+      void sdk.signMessage({
+        getProvider: () => this.getProvider(),
+        payload: {
+          network: {
+            type:
+              this.network === "mainnet"
+                ? sdk.BitcoinNetworkType.Mainnet
+                : sdk.BitcoinNetworkType.Testnet,
+          },
+          address,
+          message,
+          protocol: sdk.MessageSigningProtocols.BIP322,
+        },
+        onFinish(resp) {
+          resolve({
+            result: resp,
+            address,
+            algorithm: SignMessageAlgorithm.BIP322,
+          })
+        },
+        onCancel() {
+          reject(new UserRejectError())
+        },
+      })
+    })
+  }
+
+  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 new Promise((resolve, reject) => {
+      void sdk
+        .sendBtcTransaction({
+          getProvider: () => this.getProvider(),
+          payload: {
+            network: {
+              type:
+                this.network === WalletAdapterBitcoinNetwork.MAINNET
+                  ? sdk.BitcoinNetworkType.Mainnet
+                  : sdk.BitcoinNetworkType.Testnet,
+            },
+            message: "Send Bitcoin",
+            recipients: [
+              {
+                address: receiverAddress,
+                amountSats: BigInt(satoshiAmount),
+              },
+            ],
+            senderAddress: senderAddress.address,
+          },
+          onFinish(resp) {
+            return resolve({ txid: resp })
+          },
+          onCancel() {
+            reject(new UserRejectError())
+          },
+        })
+        .catch(reject)
+    })
+  }
+
+  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 signedPsbt = await new Promise<Uint8Array>((resolve, reject) => {
+      void sdk
+        .signTransaction({
+          getProvider: () => this.getProvider(),
+          payload: {
+            network: {
+              type:
+                this.network === WalletAdapterBitcoinNetwork.MAINNET
+                  ? sdk.BitcoinNetworkType.Mainnet
+                  : sdk.BitcoinNetworkType.Testnet,
+            },
+            message: "Sign transaction",
+            psbtBase64,
+            inputsToSign: signIndices.map(([address, signIndex]) => ({
+              address,
+              signingIndexes: [signIndex],
+            })),
+            broadcast: false,
+          },
+          onFinish(resp) {
+            resolve(base64.decode(resp.psbtBase64))
+          },
+          onCancel() {
+            reject(new UserRejectError())
+          },
+        })
+        .catch(reject)
+    })
+
+    const tx = btc.Transaction.fromPSBT(signedPsbt, {
+      allowUnknownInputs: true,
+      allowUnknownOutputs: true,
+      disableScriptCheck: true,
+      allowLegacyWitnessUtxo: true,
+    })
+    tx.finalize()
+
+    return { signedPsbtHex: hex.encode(tx.toPSBT()) }
+  }
+
+  onAddressesChanged(callback: WalletAdapter_onAddressesChanged_callback): {
+    unsubscribe: () => void
+  } {
+    throw new Error("Not implemented")
+  }
+}

package/src/utils/bitcoinAddressHelpers.ts

@@ -0,0 +1,132 @@
+import { hex } from "@scure/base"
+import * as btc from "@scure/btc-signer"
+import { Address, OutScript } from "@scure/btc-signer"
+import { BitcoinNetwork, isMainnet } from "./bitcoinNetworkHelpers"
+
+export type AddressTypeKnown = "p2pkh" | "p2sh" | "p2wpkh" | "p2wsh" | "p2tr"
+export type AddressType = AddressTypeKnown | "unknown"
+
+export function getAddressType(
+  network: BitcoinNetwork,
+  address: string,
+): AddressType {
+  if (isP2PKHAddress(network, address)) {
+    return "p2pkh"
+  } else if (isP2SHAddress(network, address)) {
+    return "p2sh"
+  } else if (isP2WPKHAddress(network, address)) {
+    return "p2wpkh"
+  } else if (isP2WSHAddress(network, address)) {
+    return "p2wsh"
+  } else if (isP2TRAddress(network, address)) {
+    return "p2tr"
+  } else {
+    return "unknown"
+  }
+}
+
+export function isP2PKHAddress(
+  network: BitcoinNetwork,
+  address: string,
+): boolean {
+  if (isMainnet(network)) {
+    return address.startsWith("1")
+  } else {
+    return address.startsWith("m") || address.startsWith("n")
+  }
+}
+
+export function isP2SHAddress(
+  network: BitcoinNetwork,
+  address: string,
+): boolean {
+  if (isMainnet(network)) {
+    return address.startsWith("3")
+  } else {
+    return address.startsWith("2")
+  }
+}
+
+export function isP2WPKHAddress(
+  network: BitcoinNetwork,
+  address: string,
+): boolean {
+  if (isMainnet(network)) {
+    return address.startsWith("bc1q")
+  } else {
+    return address.startsWith("tb1q")
+  }
+}
+
+export function isP2TRAddress(
+  network: BitcoinNetwork,
+  address: string,
+): boolean {
+  if (isMainnet(network)) {
+    return address.startsWith("bc1p")
+  } else {
+    return address.startsWith("tb1p")
+  }
+}
+
+export function isP2WSHAddress(
+  network: BitcoinNetwork,
+  address: string,
+): boolean {
+  if (isP2TRAddress(network, address)) {
+    return false
+  }
+  if (isP2WPKHAddress(network, address)) {
+    return false
+  }
+
+  if (isMainnet(network)) {
+    return address.startsWith("bc1")
+  } else {
+    return address.startsWith("tb1")
+  }
+}
+
+export function getP2TRInternalPublicKey(
+  network: BitcoinNetwork,
+  publicKey: Uint8Array,
+): Uint8Array {
+  const ecdsaPublicKeyLength = 33
+  if (publicKey.byteLength !== ecdsaPublicKeyLength) {
+    throw new Error("Invalid public key length")
+  }
+  return publicKey.slice(1)
+}
+
+export function getTapInternalKeyOf_P2TR_publicKey(
+  network: BitcoinNetwork,
+  publicKey: Uint8Array,
+): Uint8Array {
+  return btc.p2tr(
+    getP2TRInternalPublicKey(network, publicKey),
+    undefined,
+    network,
+  ).tapInternalKey
+}
+
+export function getRedeemScriptOf_P2SH_P2WPKH_publicKey(
+  network: BitcoinNetwork,
+  publicKey: Uint8Array,
+): Uint8Array {
+  return btc.p2sh(btc.p2wpkh(publicKey, network), network).redeemScript!
+}
+
+export function addressToScriptPubKey(
+  network: BitcoinNetwork,
+  address: string,
+): Uint8Array {
+  const addr = Address(network).decode(address)
+  return OutScript.encode(addr)
+}
+
+export function addressToScriptPubKeyHex(
+  network: BitcoinNetwork,
+  address: string,
+): string {
+  return hex.encode(addressToScriptPubKey(network, address))
+}

package/src/utils/bitcoinNetworkHelpers.ts

@@ -0,0 +1,17 @@
+import * as btc from "@scure/btc-signer"
+import { checkNever } from "./misc"
+
+export type BitcoinNetwork = typeof btc.NETWORK
+
+export function getBitcoinNetwork(
+  network: "mainnet" | "testnet",
+): BitcoinNetwork {
+  if (network === "mainnet") return btc.NETWORK
+  if (network === "testnet") return btc.TEST_NETWORK
+  checkNever(network as never)
+  return btc.NETWORK
+}
+
+export function isMainnet(network: BitcoinNetwork): boolean {
+  return network.bech32 === "bc"
+}

package/src/utils/createAdapterAvailability.ts

@@ -0,0 +1,92 @@
+export type GetPreconditionFn<T> = () => null | { value: T }
+
+export type InitializerFn<I, T> = (precondition: I) => T | Promise<T>
+
+export interface AvailabilitySubscription {
+  unsubscribe: () => void
+}
+
+export interface Availability<T> {
+  subscribe: (listener: (adapter: T) => void) => AvailabilitySubscription
+}
+
+export function createAvailability<I, T>({
+  getPrecondition,
+  initializer,
+  pollIntervalMs = 300,
+}: {
+  getPrecondition: GetPreconditionFn<I>
+  initializer: InitializerFn<I, T>
+  pollIntervalMs?: number
+}): Availability<T> {
+  let cachedAdapter: T | null = null
+  let polling: ReturnType<typeof setInterval> | null = null
+  let creating = false
+
+  const listeners = new Set<(adapter: T) => void>()
+
+  const stopPolling = (): void => {
+    if (polling != null) {
+      clearInterval(polling)
+      polling = null
+    }
+  }
+
+  const emit = (adapter: T): void => {
+    cachedAdapter = adapter
+    for (const listener of listeners) {
+      listener(adapter)
+    }
+  }
+
+  const attemptCreate = async (): Promise<void> => {
+    if (cachedAdapter != null || creating) return
+    const precondition = getPrecondition()
+    if (precondition == null) return
+
+    creating = true
+    try {
+      const adapter = await initializer(precondition.value)
+      emit(adapter)
+      stopPolling()
+    } catch (error) {
+      console.warn("[WalletAdapter] Failed to initialize adapter", error)
+    } finally {
+      creating = false
+    }
+  }
+
+  const ensurePolling = (): void => {
+    if (cachedAdapter != null) return
+
+    void attemptCreate()
+    if (cachedAdapter != null || polling != null) return
+
+    polling = setInterval(() => {
+      void attemptCreate()
+    }, pollIntervalMs)
+  }
+
+  return {
+    subscribe: listener => {
+      if (cachedAdapter != null) {
+        listener(cachedAdapter)
+        return { unsubscribe: () => {} }
+      }
+
+      listeners.add(listener)
+      ensurePolling()
+
+      const subscription: AvailabilitySubscription = {
+        unsubscribe: () => {
+          listeners.delete(listener)
+          if (listeners.size === 0) {
+            stopPolling()
+          }
+        },
+      }
+
+      return subscription
+    },
+  }
+}

package/src/utils/error.ts

@@ -0,0 +1,13 @@
+export class BitcoinWalletAdapterError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message, options)
+    this.name = "BitcoinWalletAdapterError"
+  }
+}
+
+export class UserRejectError extends BitcoinWalletAdapterError {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message, options)
+    this.name = "UserRejectError"
+  }
+}

package/src/utils/misc.ts

@@ -0,0 +1,10 @@
+export function hasAny<T>(ary: T[]): ary is [T, ...T[]]
+export function hasAny<T>(ary: readonly T[]): ary is readonly [T, ...T[]]
+export function hasAny<T>(ary: readonly T[]): ary is readonly [T, ...T[]] {
+  return ary.length > 0
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function checkNever(x: never): undefined {
+  return
+}