@meshconnect/uwc-bitcoin 0.2.3 → 0.2.4-snapshot.c3e9146

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/uwc-bitcoin",
-  "version": "0.2.3",
+  "version": "0.2.4-snapshot.c3e9146",
   "description": "Mesh-owned Bitcoin (bip122) namespace module for Universal Wallet Connector — network-specific logic (PSBT, address/network handling, mempool broadcast) with pluggable transport adapters (Wallet Standard bitcoin:* and WalletConnect bip122), consumed by the injected and walletConnect transport connectors",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,8 @@
     "src"
   ],
   "dependencies": {
-    "@meshconnect/uwc-types": "0.26.0"
+    "@meshconnect/uwc-constants": "0.7.4-snapshot.c3e9146",
+    "@meshconnect/uwc-types": "0.26.1-snapshot.c3e9146"
   },
   "devDependencies": {
     "typescript": "^5.9.3"

package/src/adapter.ts

@@ -1,23 +1,27 @@
 import type {
   BitcoinAccount,
+  BitcoinPsbtSignRequest,
+  BitcoinSendTransferRequest,
   BitcoinSignMessageParams,
-  SignatureType
+  SignatureType,
+  TransactionResult
 } from '@meshconnect/uwc-types'
 
 /**
  * The seam between the Bitcoin namespace module and a single transport.
  *
- * A concrete adapter (Phase 3) is constructed by its transport bound to an
+ * A concrete adapter is constructed by its transport bound to an
  * already-connected provider/session — Wallet Standard `bitcoin:*` for the
  * injected transport, WalletConnect bip122 for the WalletConnect transport —
  * so the port carries no `connect`/provider argument: connecting is the
  * transport's job. Each adapter converts between these transport-agnostic
- * domain shapes and its wallet's native interface (e.g. hex ↔ `Uint8Array`).
+ * domain shapes and its wallet's native interface (e.g. hex/base64 strings ↔
+ * `Uint8Array`).
  *
- * Phase 2 locks the grounded verify-flow methods. `signPsbt` (Path B, returns a
- * signed PSBT the module then finalizes + broadcasts) and `sendTransfer`
- * (Path A) are added alongside their concrete adapters in Phase 3 rather than
- * guessed here.
+ * `getAccounts` + `signMessage` are the always-present verify-flow methods.
+ * `signPsbt` and `sendTransfer` are optional because they map to distinct wallet
+ * paths — a Wallet Standard wallet signs a PSBT (Path B); a WalletConnect wallet
+ * does a high-level `sendTransfer` (Path A) — and not every adapter offers both.
  */
 export interface BitcoinTransportAdapter {
   /** Enumerate the bip122 accounts available on the connected session. */
@@ -26,6 +30,20 @@ export interface BitcoinTransportAdapter {
   /** Sign a message with the given account. */
   signMessage(params: BitcoinSignMessageParams): Promise<SignatureType>
 
+  /**
+   * Sign a PSBT (Path B). Returns the wallet-signed PSBT, base64-encoded — the
+   * wallet does NOT broadcast; finalizing + broadcasting is a separate step.
+   * Optional: only adapters whose wallet exposes PSBT signing implement it.
+   */
+  signPsbt?(request: BitcoinPsbtSignRequest): Promise<string>
+
+  /**
+   * High-level transfer (Path A): the wallet does coin selection, fee, signing,
+   * and broadcast, returning a txid. Optional: only adapters whose transport
+   * offers it (e.g. WalletConnect `sendTransfer`) implement it.
+   */
+  sendTransfer?(request: BitcoinSendTransferRequest): Promise<TransactionResult>
+
   /** Release any session resources the adapter holds. Optional. */
   disconnect?(): Promise<void>
 }

package/src/adapters/okx.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi } from 'vitest'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import { OkxBitcoinAdapter, type OkxBitcoinProvider } from './okx'
+import {
+  base64ToBytes,
+  bytesToBase64,
+  bytesToHex,
+  hexToBytes
+} from '../encoding'
+
+const account = { address: 'bc1qokx', publicKey: '02aabbcc' }
+
+/** A fake OKX injected bitcoin provider wired via vi mocks. */
+const fakeProvider = (
+  overrides: Partial<OkxBitcoinProvider> = {}
+): OkxBitcoinProvider => ({
+  requestAccounts: vi.fn().mockResolvedValue([account.address]),
+  getAccounts: vi.fn().mockResolvedValue([account.address]),
+  getPublicKey: vi.fn().mockResolvedValue(account.publicKey),
+  signMessage: vi.fn().mockResolvedValue('c2lnbmF0dXJl'),
+  signPsbt: vi.fn().mockResolvedValue('abcdef01'),
+  on: vi.fn(),
+  removeListener: vi.fn(),
+  ...overrides
+})
+
+describe('OkxBitcoinAdapter', () => {
+  it('getAccounts prompts via requestAccounts and pairs the active public key', async () => {
+    const provider = fakeProvider()
+    const accounts = await new OkxBitcoinAdapter(provider).getAccounts()
+
+    expect(provider.requestAccounts).toHaveBeenCalledOnce()
+    expect(accounts).toEqual([{ address: 'bc1qokx', publicKey: '02aabbcc' }])
+  })
+
+  it('getAccounts tolerates a getPublicKey failure (empty key, not a throw)', async () => {
+    const provider = fakeProvider({
+      getPublicKey: vi.fn().mockRejectedValue(new Error('locked'))
+    })
+    const accounts = await new OkxBitcoinAdapter(provider).getAccounts()
+    expect(accounts).toEqual([{ address: 'bc1qokx', publicKey: '' }])
+  })
+
+  it('signMessage maps bip322 → bip322-simple and passes the base64 signature through', async () => {
+    const provider = fakeProvider()
+    const adapter = new OkxBitcoinAdapter(provider)
+
+    const result = await adapter.signMessage({
+      account: { address: account.address, publicKey: account.publicKey },
+      message: 'verify me',
+      protocol: 'bip322'
+    })
+
+    expect(provider.signMessage).toHaveBeenCalledWith(
+      'verify me',
+      'bip322-simple'
+    )
+    expect(result).toEqual({ type: 'standard', signature: 'c2lnbmF0dXJl' })
+  })
+
+  it('signMessage defaults to ecdsa when no protocol is given', async () => {
+    const provider = fakeProvider()
+    await new OkxBitcoinAdapter(provider).signMessage({
+      account: { address: account.address, publicKey: account.publicKey },
+      message: 'hi'
+    })
+    expect(provider.signMessage).toHaveBeenCalledWith('hi', 'ecdsa')
+  })
+
+  it('signMessage throws when the provider returns no signature', async () => {
+    const provider = fakeProvider({
+      signMessage: vi.fn().mockResolvedValue('')
+    })
+    await expect(
+      new OkxBitcoinAdapter(provider).signMessage({
+        account: { address: account.address, publicKey: account.publicKey },
+        message: 'hi'
+      })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('signPsbt converts base64 → hex for OKX and hex → base64 on the way back', async () => {
+    // Round-trip fixture: a base64 PSBT whose hex the mock echoes back signed.
+    const psbtBytes = new Uint8Array([0x70, 0x73, 0x62, 0x74, 0xff])
+    const psbtB64 = bytesToBase64(psbtBytes)
+    const signedBytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef])
+    const provider = fakeProvider({
+      signPsbt: vi.fn().mockResolvedValue(bytesToHex(signedBytes))
+    })
+
+    const result = await new OkxBitcoinAdapter(provider).signPsbt({
+      from: account.address,
+      psbt: psbtB64
+    })
+
+    // OKX received the PSBT as HEX (autoFinalized:false = sign-only).
+    expect(provider.signPsbt).toHaveBeenCalledWith(bytesToHex(psbtBytes), {
+      autoFinalized: false
+    })
+    // ...and we returned it as base64.
+    expect(result).toBe(bytesToBase64(signedBytes))
+    expect(base64ToBytes(result)).toEqual(signedBytes)
+  })
+
+  it('signPsbt throws when the provider returns no PSBT', async () => {
+    const provider = fakeProvider({
+      signPsbt: vi.fn().mockResolvedValue('')
+    })
+    await expect(
+      new OkxBitcoinAdapter(provider).signPsbt({
+        from: account.address,
+        psbt: bytesToBase64(new Uint8Array([1, 2]))
+      })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('disconnect resolves (OKX has no disconnect RPC)', async () => {
+    await expect(
+      new OkxBitcoinAdapter(fakeProvider()).disconnect()
+    ).resolves.toBeUndefined()
+  })
+})
+
+describe('hexToBytes', () => {
+  it('round-trips with bytesToHex, tolerating a 0x / 0X prefix', () => {
+    const bytes = new Uint8Array([0x00, 0x0f, 0xa0, 0xff])
+    expect(hexToBytes(bytesToHex(bytes))).toEqual(bytes)
+    expect(hexToBytes('0x' + bytesToHex(bytes))).toEqual(bytes)
+    expect(hexToBytes('0X' + bytesToHex(bytes))).toEqual(bytes)
+  })
+
+  it('throws on odd-length hex', () => {
+    expect(() => hexToBytes('abc')).toThrow(/odd-length/)
+  })
+
+  it('throws on non-hex characters (no silent 0-coercion)', () => {
+    expect(() => hexToBytes('zz')).toThrow(/non-hex/)
+    expect(() => hexToBytes('12g4')).toThrow(/non-hex/)
+  })
+})

package/src/adapters/okx.ts

@@ -0,0 +1,116 @@
+import type {
+  BitcoinAccount,
+  BitcoinPsbtSignRequest,
+  BitcoinSignMessageParams,
+  SignatureType
+} from '@meshconnect/uwc-types'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import type { BitcoinTransportAdapter } from '../adapter'
+import {
+  base64ToBytes,
+  bytesToBase64,
+  bytesToHex,
+  hexToBytes
+} from '../encoding'
+
+/**
+ * The subset of OKX's injected Bitcoin provider this adapter drives
+ * (`window.okxwallet.bitcoin`). OKX does NOT expose Bitcoin through Wallet
+ * Standard — only this legacy injected provider — so it needs a dedicated
+ * adapter, not `WalletStandardBitcoinAdapter`.
+ *
+ * Wire conventions the provider follows:
+ * - `requestAccounts()` prompts + returns the authorized addresses; the caller
+ *   pairs `getPublicKey()` for the active account's compressed key (hex).
+ * - `signMessage(msg, type)` returns a base64 signature.
+ * - `signPsbt(psbtHex, options)` takes AND returns PSBT as HEX — so this adapter
+ *   converts base64 ↔ hex at the boundary (our domain is base64/BIP-174).
+ */
+export interface OkxBitcoinProvider {
+  /** Prompt for connection; returns the authorized addresses. */
+  requestAccounts(): Promise<string[]>
+  /** Non-prompting: the already-authorized addresses ([] if not connected). */
+  getAccounts(): Promise<string[]>
+  /** The active account's compressed public key, hex-encoded. */
+  getPublicKey(): Promise<string>
+  /** Sign a message; returns a base64 signature. */
+  signMessage(
+    message: string,
+    type?: 'ecdsa' | 'bip322-simple'
+  ): Promise<string>
+  /** Sign a PSBT (hex in, signed PSBT hex out). */
+  signPsbt(
+    psbtHex: string,
+    options?: { autoFinalized?: boolean }
+  ): Promise<string>
+  on(event: string, handler: (accounts: string[]) => void): void
+  removeListener(event: string, handler: (accounts: string[]) => void): void
+}
+
+/**
+ * OKX (legacy injected) Bitcoin transport adapter — the non-Wallet-Standard
+ * injected path. The injected transport resolves `window.okxwallet.bitcoin` by
+ * its `injectedId` and hands it here; this adapter maps our domain shapes onto
+ * the provider's methods.
+ *
+ * `sendTransfer` is intentionally not implemented — that is the WalletConnect
+ * high-level path. (OKX has `sendBitcoin`, but broadcast is out of scope here:
+ * this stays sign-only, matching `WalletStandardBitcoinAdapter`.)
+ */
+export class OkxBitcoinAdapter implements BitcoinTransportAdapter {
+  constructor(private readonly provider: OkxBitcoinProvider) {}
+
+  async getAccounts(): Promise<BitcoinAccount[]> {
+    const addresses = await this.provider.requestAccounts()
+    // The provider exposes one active public key; pair it with the first
+    // (active) address. Tolerate a missing key rather than failing the connect.
+    let publicKey = ''
+    try {
+      publicKey = await this.provider.getPublicKey()
+    } catch {
+      publicKey = ''
+    }
+    return addresses.map((address, index) => ({
+      address,
+      publicKey: index === 0 ? publicKey : ''
+    }))
+  }
+
+  async signMessage(params: BitcoinSignMessageParams): Promise<SignatureType> {
+    // OKX signs with its OWN active account (no address param), so the caller's
+    // `params.account` is advisory here. Map our protocol name to the
+    // provider's ('bip322' → 'bip322-simple').
+    const type = params.protocol === 'bip322' ? 'bip322-simple' : 'ecdsa'
+    const signature = await this.provider.signMessage(params.message, type)
+    if (!signature) {
+      throw new WalletConnectorError({
+        type: 'unknown',
+        message: 'okx bitcoin: signMessage returned no signature'
+      })
+    }
+    // OKX returns a base64 signature — matches our contract.
+    return { type: 'standard', signature }
+  }
+
+  async signPsbt(request: BitcoinPsbtSignRequest): Promise<string> {
+    // Our domain is base64 (BIP-174); OKX speaks hex. autoFinalized:false keeps
+    // this sign-only (the wallet returns the signed-but-unfinalized PSBT).
+    const psbtHex = bytesToHex(base64ToBytes(request.psbt))
+    const signedHex = await this.provider.signPsbt(psbtHex, {
+      autoFinalized: false
+    })
+    if (!signedHex) {
+      throw new WalletConnectorError({
+        type: 'unknown',
+        message: 'okx bitcoin: signPsbt returned no PSBT'
+      })
+    }
+    return bytesToBase64(hexToBytes(signedHex))
+  }
+
+  disconnect(): Promise<void> {
+    // OKX's injected provider has no disconnect RPC; clearing session state is
+    // the caller's job.
+    return Promise.resolve()
+  }
+}

package/src/adapters/wallet-standard.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi } from 'vitest'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import {
+  WalletStandardBitcoinAdapter,
+  type WalletStandardBitcoinAccount,
+  type WalletStandardBitcoinWallet
+} from './wallet-standard'
+import { base64ToBytes, bytesToBase64, utf8ToBytes } from '../encoding'
+
+const wsAccount: WalletStandardBitcoinAccount = {
+  address: 'bc1qpayment',
+  publicKey: new Uint8Array([2, 0xaa, 0xbb, 0xcc]),
+  purpose: 'payment'
+}
+
+/** A fake `bitcoin:*` wallet with all three features wired via vi mocks. */
+const fakeWallet = (
+  overrides: Partial<WalletStandardBitcoinWallet['features']> = {}
+): WalletStandardBitcoinWallet => ({
+  name: 'Fake BTC Wallet',
+  accounts: [],
+  features: {
+    'bitcoin:connect': {
+      connect: vi.fn().mockResolvedValue({ accounts: [wsAccount] })
+    },
+    'bitcoin:signMessage': {
+      signMessage: vi.fn().mockResolvedValue([
+        {
+          signature: new Uint8Array([1, 2, 3]),
+          signedMessage: new Uint8Array()
+        }
+      ])
+    },
+    'bitcoin:signTransaction': {
+      signTransaction: vi
+        .fn()
+        .mockResolvedValue([{ psbt: new Uint8Array([9, 8, 7]) }])
+    },
+    ...overrides
+  }
+})
+
+describe('WalletStandardBitcoinAdapter', () => {
+  it('getAccounts connects and maps accounts to hex publicKey', async () => {
+    const wallet = fakeWallet()
+    const adapter = new WalletStandardBitcoinAdapter(wallet)
+
+    const accounts = await adapter.getAccounts()
+
+    expect(wallet.features['bitcoin:connect']!.connect).toHaveBeenCalledWith({
+      purposes: ['payment']
+    })
+    expect(accounts).toEqual([
+      { address: 'bc1qpayment', publicKey: '02aabbcc', purpose: 'payment' }
+    ])
+  })
+
+  it('signMessage encodes the message and returns a base64 standard signature', async () => {
+    const wallet = fakeWallet()
+    const adapter = new WalletStandardBitcoinAdapter(wallet)
+
+    const sig = await adapter.signMessage({
+      account: { address: 'bc1qpayment', publicKey: '02aabbcc' },
+      message: 'verify me'
+    })
+
+    const call = (
+      wallet.features['bitcoin:signMessage']!.signMessage as ReturnType<
+        typeof vi.fn
+      >
+    ).mock.calls[0][0]
+    expect(call.account).toBe(wsAccount)
+    expect(call.message).toEqual(utf8ToBytes('verify me'))
+    expect(sig).toEqual({
+      type: 'standard',
+      signature: bytesToBase64(new Uint8Array([1, 2, 3]))
+    })
+  })
+
+  it('signPsbt round-trips base64 <-> bytes and returns the signed PSBT', async () => {
+    const wallet = fakeWallet()
+    const adapter = new WalletStandardBitcoinAdapter(wallet)
+    const psbt = bytesToBase64(new Uint8Array([10, 20, 30]))
+
+    const signed = await adapter.signPsbt({ from: 'bc1qpayment', psbt })
+
+    const call = (
+      wallet.features['bitcoin:signTransaction']!.signTransaction as ReturnType<
+        typeof vi.fn
+      >
+    ).mock.calls[0][0]
+    expect(call.account).toBe(wsAccount)
+    expect(call.psbt).toEqual(base64ToBytes(psbt))
+    expect(signed).toBe(bytesToBase64(new Uint8Array([9, 8, 7])))
+  })
+
+  it('signPsbt maps inputsToSign accounts by address', async () => {
+    const wallet = fakeWallet()
+    const adapter = new WalletStandardBitcoinAdapter(wallet)
+    await adapter.getAccounts()
+
+    await adapter.signPsbt({
+      from: 'bc1qpayment',
+      psbt: bytesToBase64(new Uint8Array([1])),
+      inputsToSign: [
+        { address: 'bc1qpayment', signingIndexes: [0], sigHash: 'ALL' }
+      ]
+    })
+
+    const call = (
+      wallet.features['bitcoin:signTransaction']!.signTransaction as ReturnType<
+        typeof vi.fn
+      >
+    ).mock.calls[0][0]
+    expect(call.inputsToSign).toEqual([
+      { account: wsAccount, signingIndexes: [0], sigHash: 'ALL' }
+    ])
+  })
+
+  it('throws for an address with no connected account', async () => {
+    const wallet = fakeWallet()
+    const adapter = new WalletStandardBitcoinAdapter(wallet)
+
+    await expect(
+      adapter.signMessage({
+        account: { address: 'bc1qunknown', publicKey: '00' },
+        message: 'x'
+      })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('throws when the wallet lacks the signTransaction feature', async () => {
+    const wallet = fakeWallet({ 'bitcoin:signTransaction': undefined })
+    const adapter = new WalletStandardBitcoinAdapter(wallet)
+
+    await expect(
+      adapter.signPsbt({
+        from: 'bc1qpayment',
+        psbt: bytesToBase64(new Uint8Array([1]))
+      })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
+
+  it('does not implement sendTransfer (Wallet Standard has no high-level transfer)', () => {
+    const adapter = new WalletStandardBitcoinAdapter(fakeWallet())
+    expect(adapter.sendTransfer).toBeUndefined()
+  })
+})

package/src/adapters/wallet-standard.ts

@@ -0,0 +1,194 @@
+import type {
+  BitcoinAccount,
+  BitcoinPsbtSignRequest,
+  BitcoinSignMessageParams,
+  SignatureType
+} from '@meshconnect/uwc-types'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import type { BitcoinTransportAdapter } from '../adapter'
+import {
+  base64ToBytes,
+  bytesToBase64,
+  bytesToHex,
+  utf8ToBytes
+} from '../encoding'
+
+/**
+ * The subset of the Wallet Standard `bitcoin:*` interface this adapter drives.
+ * Structural (no `@wallet-standard/*` dependency); grounded on the community
+ * bitcoin-wallet-standard interface that MetaMask exposes. (OKX signs BTC too,
+ * but via a legacy injected provider, not Wallet Standard — it needs a separate
+ * adapter, not this one.)
+ * @see https://github.com/ExodusMovement/bitcoin-wallet-standard
+ */
+export interface WalletStandardBitcoinAccount {
+  address: string
+  publicKey: Uint8Array
+  purpose?: 'payment' | 'ordinals'
+}
+
+interface BitcoinConnectFeature {
+  connect(input: {
+    purposes: ('payment' | 'ordinals')[]
+  }): Promise<{ accounts: WalletStandardBitcoinAccount[] }>
+}
+
+interface BitcoinSignMessageFeature {
+  signMessage(input: {
+    account: WalletStandardBitcoinAccount
+    message: Uint8Array
+    protocol?: 'ecdsa' | 'bip322'
+  }): Promise<{ signature: Uint8Array; signedMessage: Uint8Array }[]>
+}
+
+interface BitcoinSignTransactionFeature {
+  signTransaction(input: {
+    account: WalletStandardBitcoinAccount
+    psbt: Uint8Array
+    inputsToSign?: {
+      account: WalletStandardBitcoinAccount
+      signingIndexes: number[]
+      sigHash?: string
+    }[]
+  }): Promise<{ psbt: Uint8Array }[]>
+}
+
+/** The handle the injected transport passes in (a discovered `bitcoin:*` wallet). */
+export interface WalletStandardBitcoinWallet {
+  name: string
+  accounts: readonly WalletStandardBitcoinAccount[]
+  features: Record<string, unknown> & {
+    'bitcoin:connect'?: BitcoinConnectFeature
+    'bitcoin:signMessage'?: BitcoinSignMessageFeature
+    'bitcoin:signTransaction'?: BitcoinSignTransactionFeature
+  }
+}
+
+/**
+ * Wallet Standard (`bitcoin:*`) transport adapter — the injected path for
+ * wallets that speak Wallet Standard (verified: MetaMask). The injected
+ * transport discovers the wallet and hands it here; this adapter performs the
+ * bip122-specific operations against it, converting hex/base64 ↔ `Uint8Array`
+ * at the boundary.
+ *
+ * `sendTransfer` is intentionally not implemented — Wallet Standard has no
+ * high-level transfer; that is the WalletConnect adapter's path.
+ */
+export class WalletStandardBitcoinAdapter implements BitcoinTransportAdapter {
+  private accounts: readonly WalletStandardBitcoinAccount[] | null = null
+
+  /**
+   * @param wallet The discovered `bitcoin:*` wallet.
+   * @param initialAccounts Optional already-authorized accounts to seed the
+   *   cache with. Passed on the SILENT restore path so the first
+   *   `signMessage`/`signPsbt` doesn't re-invoke `bitcoin:connect` (which some
+   *   wallets surface as UI) via `requireAccount`→`getAccounts`. Omit on a
+   *   fresh connect, where `getAccounts()` should call `bitcoin:connect` to
+   *   authorize.
+   */
+  constructor(
+    private readonly wallet: WalletStandardBitcoinWallet,
+    initialAccounts?: readonly WalletStandardBitcoinAccount[]
+  ) {
+    if (initialAccounts && initialAccounts.length > 0) {
+      this.accounts = initialAccounts
+    }
+  }
+
+  async getAccounts(): Promise<BitcoinAccount[]> {
+    const connect = this.wallet.features['bitcoin:connect']
+    // The wallet exposes accounts only after `bitcoin:connect`; fall back to any
+    // it already lists (a wallet without the connect feature).
+    this.accounts = connect
+      ? (await connect.connect({ purposes: ['payment'] })).accounts
+      : this.wallet.accounts
+
+    return this.accounts.map(account => ({
+      address: account.address,
+      publicKey: bytesToHex(account.publicKey),
+      ...(account.purpose ? { purpose: account.purpose } : {})
+    }))
+  }
+
+  async signMessage(params: BitcoinSignMessageParams): Promise<SignatureType> {
+    const feature = this.wallet.features['bitcoin:signMessage']
+    if (!feature) {
+      throw this.unsupported('signMessage')
+    }
+    const account = await this.requireAccount(params.account.address)
+    const [result] = await feature.signMessage({
+      account,
+      message: utf8ToBytes(params.message),
+      ...(params.protocol ? { protocol: params.protocol } : {})
+    })
+    if (!result) {
+      throw new WalletConnectorError({
+        type: 'unknown',
+        message: 'wallet-standard bitcoin: signMessage returned no signature'
+      })
+    }
+    return { type: 'standard', signature: bytesToBase64(result.signature) }
+  }
+
+  async signPsbt(request: BitcoinPsbtSignRequest): Promise<string> {
+    const feature = this.wallet.features['bitcoin:signTransaction']
+    if (!feature) {
+      throw this.unsupported('signPsbt')
+    }
+    const account = await this.requireAccount(request.from)
+    const inputsToSign = request.inputsToSign
+      ? await Promise.all(
+          request.inputsToSign.map(async input => ({
+            account: await this.requireAccount(input.address),
+            signingIndexes: input.signingIndexes,
+            ...(input.sigHash ? { sigHash: input.sigHash } : {})
+          }))
+        )
+      : undefined
+    const [result] = await feature.signTransaction({
+      account,
+      psbt: base64ToBytes(request.psbt),
+      ...(inputsToSign ? { inputsToSign } : {})
+    })
+    if (!result) {
+      throw new WalletConnectorError({
+        type: 'unknown',
+        message: 'wallet-standard bitcoin: signTransaction returned no PSBT'
+      })
+    }
+    return bytesToBase64(result.psbt)
+  }
+
+  disconnect(): Promise<void> {
+    this.accounts = null
+    return Promise.resolve()
+  }
+
+  /** Look up the wallet-native account for an address, connecting first if needed. */
+  private async requireAccount(
+    address: string
+  ): Promise<WalletStandardBitcoinAccount> {
+    if (!this.accounts) await this.getAccounts()
+    const account =
+      this.accounts?.find(a => a.address === address) ??
+      // The cached set is from an earlier authorize; the wallet may have since
+      // switched accounts (its `accounts` update in place). Re-check the
+      // wallet's CURRENT accounts before failing — so signing the live account
+      // after a switch resolves without re-invoking `bitcoin:connect`.
+      this.wallet.accounts?.find(a => a.address === address)
+    if (!account) {
+      throw new WalletConnectorError({
+        type: 'unknown',
+        message: `wallet-standard bitcoin: no connected account for "${address}"`
+      })
+    }
+    return account
+  }
+
+  private unsupported(method: string): WalletConnectorError {
+    return new WalletConnectorError({
+      type: 'unknown',
+      message: `wallet-standard bitcoin: this wallet does not support ${method}`
+    })
+  }
+}