bitcoin-wallet-connector 0.1.0

package/src/adapters/LeatherWalletAdapter.impl.ts

@@ -0,0 +1,324 @@
+import type { RequestFn, RpcErrorBody, RpcErrorResponse } from "@leather.io/rpc"
+import { hex } from "@scure/base"
+import {
+  addressToScriptPubKey,
+  getTapInternalKeyOf_P2TR_publicKey,
+} from "../utils/bitcoinAddressHelpers"
+import { getBitcoinNetwork } from "../utils/bitcoinNetworkHelpers"
+import { UserRejectError, BitcoinWalletAdapterError } from "../utils/error"
+import {
+  SignMessageAlgorithm,
+  SignMessageResult,
+  WalletAdapter,
+  WalletAdapter_onAddressesChanged_callback,
+  WalletAdapterAddress,
+  WalletAdapterAddressPurpose,
+  WalletAdapterAddressType,
+  WalletAdapterBitcoinNetwork,
+  WalletAdapterNotConnectedError,
+} from "../WalletAdapters.types"
+
+type GetAddressesResponseData = any
+
+/**
+ * https://github.com/leather-io/mono/blob/a664e64040fed1c25abef1f8864a1c7fae5444c1/packages/rpc/src/rpc/schemas.ts#L64-L78
+ */
+enum RpcErrorCode {
+  // Spec defined server errors
+  PARSE_ERROR = -32700,
+  INVALID_REQUEST = -32600,
+  METHOD_NOT_FOUND = -32601,
+  INVALID_PARAMS = -32602,
+  INTERNAL_ERROR = -32603,
+  SERVER_ERROR = -32000,
+  // Client defined errors
+  USER_REJECTION = 4001,
+  METHOD_NOT_SUPPORTED = 4002,
+  // gRPC spec borrowed
+  PERMISSION_DENIED = 7,
+  UNAUTHENTICATED = 16,
+}
+
+type Addresses = (WalletAdapterAddress & { publicKey: string })[]
+
+const LEATHER_PROVIDER_ID = "LeatherProvider.BitcoinProvider"
+
+const localStorageKey = `app:${LEATHER_PROVIDER_ID}:`
+
+/**
+ * Derivation path (BIP-84): m/84'/0'/ account_index '/0/0
+ */
+export class LeatherWalletAdapterImpl implements WalletAdapter {
+  constructor(private request: RequestFn) {}
+
+  private readonly walletDisplayName = "Leather"
+
+  private retrieveConnectedAddress(): GetAddressesResponseData | undefined {
+    let resp: GetAddressesResponseData | undefined
+    const stored = localStorage.getItem(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(localStorageKey)
+      }
+    }
+    return resp
+  }
+
+  async connect(): Promise<void> {
+    if (this.retrieveConnectedAddress() == null) {
+      const resp = await handleRpcError(
+        /**
+         * https://leather.gitbook.io/developers/bitcoin/connect-users/get-addresses
+         */
+        this.request("getAddresses"),
+      )
+      localStorage.setItem(localStorageKey, JSON.stringify(resp))
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    localStorage.removeItem(localStorageKey)
+    return Promise.resolve()
+  }
+
+  async getAddresses(): Promise<Addresses> {
+    const resp = this.retrieveConnectedAddress()
+
+    if (resp == null) {
+      throw new WalletAdapterNotConnectedError(this.walletDisplayName)
+    }
+
+    const addresses = resp.addresses.filter(
+      (a: any) => (a as any).symbol === "BTC" && a.type,
+    )
+
+    const isMainnet = addresses
+      .filter((a: any) => a.type === "p2tr")[0]
+      .address.startsWith("bc")
+
+    return addresses.map((a: any) => ({
+      network: isMainnet
+        ? WalletAdapterBitcoinNetwork.MAINNET
+        : WalletAdapterBitcoinNetwork.TESTNET,
+      purposes:
+        a.type === "p2tr"
+          ? [
+              WalletAdapterAddressPurpose.Ordinals,
+              WalletAdapterAddressPurpose.BRC20,
+              WalletAdapterAddressPurpose.Runes,
+            ]
+          : [WalletAdapterAddressPurpose.Bitcoin],
+      addressType:
+        a.type === "p2tr"
+          ? WalletAdapterAddressType.P2TR
+          : WalletAdapterAddressType.P2WPKH,
+      address: a.address,
+      scriptPubKey: hex.encode(
+        addressToScriptPubKey(
+          getBitcoinNetwork(isMainnet ? "mainnet" : "testnet"),
+          a.address,
+        ),
+      ),
+      publicKey: a.publicKey!,
+      tapInternalKey:
+        a.type === "p2tr"
+          ? hex.encode(
+              getTapInternalKeyOf_P2TR_publicKey(
+                getBitcoinNetwork(isMainnet ? "mainnet" : "testnet"),
+                hex.decode(a.publicKey!),
+              ),
+            )
+          : undefined,
+    }))
+  }
+
+  async signMessage(
+    address: string,
+    message: string,
+  ): Promise<SignMessageResult> {
+    const accounts = await this.getAddresses()
+
+    const addressType = accounts.find(a => a.address === address)?.addressType
+
+    // prettier-ignore
+    const paymentType =
+      addressType === WalletAdapterAddressType.P2WPKH ? 'p2wpkh' as const :
+      addressType === WalletAdapterAddressType.P2TR ? 'p2tr' as const :
+      undefined
+    if (paymentType == null) {
+      throw new BitcoinWalletAdapterError("Address is not supported")
+    }
+
+    const resp: any = await handleRpcError(
+      /**
+       * https://leather.gitbook.io/developers/bitcoin-methods/signmessage
+       */
+      this.request("signMessage", {
+        message,
+        paymentType,
+      }),
+    )
+
+    return {
+      algorithm:
+        resp.algorithm === "ecdsa"
+          ? SignMessageAlgorithm.ECDSA
+          : SignMessageAlgorithm.BIP322,
+      result: resp.signature,
+      address,
+      publicKey: resp.publicKey,
+    }
+  }
+
+  sendBitcoinFeeRateCapability = "required" as const
+  async sendBitcoin(
+    fromAddress: string,
+    receiverAddress: string,
+    satoshiAmount: bigint,
+    options?: { feeRate?: number },
+  ): Promise<{ txid: string }> {
+    const resp: any = await handleRpcError(
+      /**
+       * https://leather.gitbook.io/developers/bitcoin-methods/sendbitcoin
+       */
+      (this.request as any)("sendBitcoin", {
+        origin: fromAddress,
+        destination: receiverAddress,
+        amount: satoshiAmount,
+        feeRate: options?.feeRate,
+      }),
+    )
+    return { txid: resp.txid }
+  }
+
+  sendInscriptionFeeRateCapability = "available" as const
+
+  async sendInscription(
+    fromAddress: string,
+    receiverAddress: string,
+    inscriptionId: string,
+    options?: { feeRate?: number },
+  ): Promise<{ txid: string }> {
+    const { txid }: any = await handleRpcError(
+      /**
+       * https://leather.gitbook.io/developers/ordinals/send-ordinals
+       */
+      (this.request as any)("sendOrdinals", {
+        ordinals: [
+          {
+            destination: receiverAddress,
+            id: inscriptionId,
+          },
+        ],
+        paymentType: "p2wpkh",
+        sender: fromAddress,
+        feeRate: options?.feeRate,
+      }),
+    )
+    return { txid }
+  }
+
+  async signAndFinalizePsbt(
+    psbtHex: string,
+    signIndices: [address: string, signIndex: number][],
+  ): Promise<{
+    signedPsbtHex: string
+  }> {
+    const accounts = await this.getAddresses()
+    const signingAccount = accounts.find(
+      account => account.address === signIndices[0]?.[0],
+    )
+    if (signingAccount == null) {
+      throw new WalletAdapterNotConnectedError(this.walletDisplayName)
+    }
+
+    const resp: any = await handleRpcError(
+      /**
+       * https://leather.gitbook.io/developers/bitcoin-methods/signandfinalizepsbt
+       */
+      (this.request as any)("signAndFinalizePsbt", {
+        hex: psbtHex,
+        inputsToSign: signIndices.map(([address, signIndex]) => ({
+          address,
+          signingIndexes: [signIndex],
+          signatureHash: undefined,
+          disableTweakSigner: undefined,
+        })),
+        paymentType:
+          signingAccount.addressType === WalletAdapterAddressType.P2TR
+            ? "p2tr"
+            : "p2wpkh",
+      }),
+    )
+
+    return { signedPsbtHex: resp.hex }
+  }
+
+  onAddressesChanged(callback: WalletAdapter_onAddressesChanged_callback): {
+    unsubscribe: () => void
+  } {
+    // Leather doesn't provide event, fallback to polling
+    let stopped = false
+
+    const tick = async (): Promise<void> => {
+      if (stopped) return
+      try {
+        const addresses = await this.getAddresses()
+        callback({ addresses })
+      } catch (error) {
+        if (error instanceof WalletAdapterNotConnectedError) {
+          stopped = true
+          return
+        }
+        console.warn("[Leather] Failed to get addresses on change:", error)
+      } finally {
+        if (!stopped) {
+          setTimeout(tick, 1000)
+        }
+      }
+    }
+
+    setTimeout(tick, 1000)
+
+    return {
+      unsubscribe: () => {
+        stopped = true
+      },
+    }
+  }
+}
+
+export class LeatherWalletAdapterError extends BitcoinWalletAdapterError {
+  constructor(rpcError: RpcErrorResponse<RpcErrorBody>) {
+    super("Leather wallet error: " + rpcError.error.message, {
+      cause: rpcError,
+    })
+  }
+}
+
+const handleRpcError = async <T>(
+  promise: Promise<T>,
+): Promise<NonNullable<T>> => {
+  try {
+    return (await promise) as NonNullable<T>
+  } catch (e: any) {
+    if (e instanceof UserRejectError) {
+      throw e
+    }
+
+    if (e.error?.code === RpcErrorCode.USER_REJECTION) {
+      throw new UserRejectError()
+    }
+
+    throw new LeatherWalletAdapterError(e)
+  }
+}

package/src/adapters/LeatherWalletAdapter.ts

@@ -0,0 +1,35 @@
+import type { RequestFn } from "@leather.io/rpc"
+import { createAvailability } from "../utils/createAdapterAvailability"
+import type {
+  WalletAdapter,
+  WalletAdapterStatic,
+} from "../WalletAdapters.types"
+
+const adapterId = "LeatherProvider.BitcoinProvider"
+
+const metadata = {
+  name: "Leather",
+  iconUrl: import("../_/leather.svg").then(m => m.default),
+  websiteUrl: "https://leather.io/",
+  downloadUrl: "https://leather.io/wallet",
+}
+
+const availability = createAvailability<RequestFn, WalletAdapter>({
+  getPrecondition: () => {
+    const request = (window as any).LeatherProvider?.request as
+      | RequestFn
+      | undefined
+    return request == null ? null : { value: request }
+  },
+  initializer: async request => {
+    const { LeatherWalletAdapterImpl } =
+      await import("./LeatherWalletAdapter.impl")
+    return new LeatherWalletAdapterImpl(request)
+  },
+})
+
+export const LeatherWalletAdapter: WalletAdapterStatic<WalletAdapter> = {
+  adapterId,
+  metadata,
+  getAdapter: () => availability,
+}

package/src/adapters/MagicEdenWalletAdapter.impl.ts

@@ -0,0 +1,139 @@
+import { hex } from "@scure/base"
+import { addressToScriptPubKey } from "../utils/bitcoinAddressHelpers"
+import { getBitcoinNetwork } from "../utils/bitcoinNetworkHelpers"
+import {
+  WalletAdapter,
+  WalletAdapter_onAddressesChanged_callback,
+  WalletAdapterAddressPurpose,
+  WalletAdapterAddressType,
+  WalletAdapterBitcoinNetwork,
+} from "../WalletAdapters.types"
+import {
+  XverseCompatibleWalletAdapterImpl_legacy,
+  XverseCompatibleWalletAdapterImplAddress,
+} from "../utils/XverseCompatibleWalletAdapterImpl_legacy"
+import { MAGICEDEN_PROVIDER_ID } from "./MagicEdenWalletAdapter"
+
+interface MagicEdenBitcoinProviderEvents {
+  accountsChanged: [
+    event: {
+      accounts: import("sats-connect").GetAddressResponse["addresses"]
+    },
+  ]
+}
+
+export interface MagicEdenBitcoinProvider {
+  isMagicEden: boolean
+  on: <K extends keyof MagicEdenBitcoinProviderEvents>(
+    event: K,
+    handler: (...args: MagicEdenBitcoinProviderEvents[K]) => void,
+  ) => void
+  removeListener: <K extends keyof MagicEdenBitcoinProviderEvents>(
+    event: K,
+    handler: (...args: MagicEdenBitcoinProviderEvents[K]) => void,
+  ) => void
+}
+
+const localStorageKey = `app:${MAGICEDEN_PROVIDER_ID}:`
+
+export class MagicEdenWalletAdapterImpl
+  extends XverseCompatibleWalletAdapterImpl_legacy
+  implements WalletAdapter
+{
+  private magicEden: MagicEdenBitcoinProvider
+
+  constructor(
+    network: WalletAdapterBitcoinNetwork,
+    provider: MagicEdenBitcoinProvider,
+  ) {
+    super({
+      network,
+      localStorageKey,
+      walletDisplayName: "Magic Eden",
+      getProvider: async () => {
+        return provider as any
+      },
+      parseAddresses: async ({ sdk, addresses }) => {
+        const isMainnet = addresses
+          .filter(a => a.purpose === sdk.AddressPurpose.Ordinals)[0]
+          .address.startsWith("bc")
+
+        return addresses.flatMap(
+          (a): XverseCompatibleWalletAdapterImplAddress[] => {
+            if (a.purpose === sdk.AddressPurpose.Payment) {
+              return [
+                {
+                  addressType: WalletAdapterAddressType.P2WPKH,
+                  purposes: [WalletAdapterAddressPurpose.Bitcoin],
+                  address: a.address,
+                  network: this.network,
+                  scriptPubKey: hex.encode(
+                    addressToScriptPubKey(
+                      getBitcoinNetwork(isMainnet ? "mainnet" : "testnet"),
+                      a.address,
+                    ),
+                  ),
+                  publicKey: a.publicKey,
+                },
+              ]
+            }
+
+            if (a.purpose === sdk.AddressPurpose.Ordinals) {
+              return [
+                {
+                  addressType: WalletAdapterAddressType.P2TR,
+                  purposes: [
+                    WalletAdapterAddressPurpose.Ordinals,
+                    WalletAdapterAddressPurpose.BRC20,
+                    WalletAdapterAddressPurpose.Runes,
+                  ],
+                  address: a.address,
+                  network: this.network,
+                  scriptPubKey: hex.encode(
+                    addressToScriptPubKey(
+                      getBitcoinNetwork(isMainnet ? "mainnet" : "testnet"),
+                      a.address,
+                    ),
+                  ),
+                  publicKey: a.publicKey,
+                  tapInternalKey: a.publicKey,
+                },
+              ]
+            }
+
+            return []
+          },
+        )
+      },
+    })
+    this.magicEden = provider
+  }
+
+  onAddressesChanged(callback: WalletAdapter_onAddressesChanged_callback): {
+    unsubscribe: () => void
+  } {
+    // MagicEden uses accountsChanged event
+    // https://docs-wallet.magiceden.io/bitcoin/provider-events
+    const provider = this.magicEden
+
+    const handler = async (event: {
+      accounts: import("sats-connect").GetAddressResponse["addresses"]
+    }): Promise<void> => {
+      try {
+        await this.updateConnectedAddress(event.accounts)
+        const addresses = await this.getAddresses()
+        callback({ addresses })
+      } catch (error) {
+        console.warn("[Magic Eden] Failed to get addresses on change:", error)
+      }
+    }
+
+    provider.on("accountsChanged", handler)
+
+    return {
+      unsubscribe: () => {
+        provider.removeListener("accountsChanged", handler)
+      },
+    }
+  }
+}

package/src/adapters/MagicEdenWalletAdapter.ts

@@ -0,0 +1,51 @@
+import type {
+  WalletAdapter,
+  WalletAdapterBitcoinNetwork,
+  WalletAdapterStatic,
+} from "../WalletAdapters.types"
+import { createAvailability } from "../utils/createAdapterAvailability"
+import type { MagicEdenBitcoinProvider } from "./MagicEdenWalletAdapter.impl"
+
+declare global {
+  interface Window {
+    magicEden?: {
+      bitcoin?: MagicEdenBitcoinProvider
+    }
+  }
+}
+
+export const MAGICEDEN_PROVIDER_ID = "magiceden.bitcoin"
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const buildAvailability = (network: WalletAdapterBitcoinNetwork) =>
+  createAvailability<MagicEdenBitcoinProvider, WalletAdapter>({
+    getPrecondition: () => {
+      const provider = window.magicEden?.bitcoin
+      return provider?.isMagicEden ? { value: provider } : null
+    },
+    initializer: async provider => {
+      const { MagicEdenWalletAdapterImpl } =
+        await import("./MagicEdenWalletAdapter.impl")
+      return new MagicEdenWalletAdapterImpl(network, provider)
+    },
+  })
+
+export const MagicEdenWalletAdapterFactory = (
+  network: WalletAdapterBitcoinNetwork,
+): WalletAdapterStatic<WalletAdapter> => {
+  const availability = buildAvailability(network)
+
+  return {
+    adapterId: MAGICEDEN_PROVIDER_ID,
+    /**
+     * https://docs-wallet.magiceden.io/resources/logos-and-brand-assets
+     */
+    metadata: {
+      name: "Magic Eden",
+      iconUrl: import("../_/magiceden.png").then(m => m.default),
+      websiteUrl: "https://wallet.magiceden.io/",
+      downloadUrl: "https://wallet.magiceden.io/download",
+    },
+    getAdapter: () => availability,
+  }
+}