@meshconnect/uwc-bitcoin 0.2.4 → 0.3.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AACxD,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAA;AACzE,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAClD,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -1,2 +1,5 @@
 export { BitcoinNamespace, assertBitcoinNetwork, BITCOIN_NAMESPACE } from './bitcoin-namespace';
+export { WalletStandardBitcoinAdapter } from './adapters/wallet-standard';
+export { OkxBitcoinAdapter } from './adapters/okx';
+export { bytesToHex, hexToBytes } from './encoding';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAA;AAKzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAElD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/uwc-bitcoin",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "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.1"
+    "@meshconnect/uwc-constants": "0.7.5",
+    "@meshconnect/uwc-types": "0.27.0"
   },
   "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,176 @@
+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('maps inputsToSign → toSignInputs (index/address + numeric sighash)', async () => {
+    const provider = fakeProvider()
+    await new OkxBitcoinAdapter(provider).signPsbt({
+      from: 'bc1qokx',
+      psbt: bytesToBase64(new Uint8Array([1, 2])),
+      inputsToSign: [
+        { address: 'bc1qa', signingIndexes: [0, 2] },
+        {
+          address: 'bc1qb',
+          signingIndexes: [1],
+          sigHash: 'SINGLE|ANYONECANPAY'
+        }
+      ]
+    })
+
+    expect(provider.signPsbt).toHaveBeenCalledWith(expect.any(String), {
+      autoFinalized: false,
+      toSignInputs: [
+        { index: 0, address: 'bc1qa' },
+        { index: 2, address: 'bc1qa' },
+        { index: 1, address: 'bc1qb', sighashTypes: [0x83] }
+      ]
+    })
+  })
+
+  it('omits toSignInputs entirely when no inputsToSign is given', async () => {
+    const provider = fakeProvider()
+    await new OkxBitcoinAdapter(provider).signPsbt({
+      from: 'bc1qokx',
+      psbt: bytesToBase64(new Uint8Array([1, 2]))
+    })
+    expect(provider.signPsbt).toHaveBeenCalledWith(expect.any(String), {
+      autoFinalized: false
+    })
+  })
+
+  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,155 @@
+import type {
+  BitcoinAccount,
+  BitcoinPsbtSignRequest,
+  BitcoinSigHash,
+  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). `toSignInputs` scopes which
+   * inputs to sign (index + expected address, optional sighash), mirroring the
+   * Wallet Standard adapter's `inputsToSign`; omitted → the wallet signs all it
+   * can.
+   */
+  signPsbt(
+    psbtHex: string,
+    options?: {
+      autoFinalized?: boolean
+      toSignInputs?: {
+        index: number
+        address: string
+        sighashTypes?: number[]
+      }[]
+    }
+  ): Promise<string>
+  on(event: string, handler: (accounts: string[]) => void): void
+  removeListener(event: string, handler: (accounts: string[]) => void): void
+}
+
+/** Bitcoin SIGHASH flag → numeric value (Bitcoin Core encoding) for the
+ * provider's `toSignInputs.sighashTypes`. */
+const SIGHASH_VALUES: Record<BitcoinSigHash, number> = {
+  ALL: 0x01,
+  NONE: 0x02,
+  SINGLE: 0x03,
+  'ALL|ANYONECANPAY': 0x81,
+  'NONE|ANYONECANPAY': 0x82,
+  'SINGLE|ANYONECANPAY': 0x83
+}
+
+/**
+ * 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))
+    // Forward which inputs to sign (index + address, optional sighash) so the
+    // wallet signs exactly the requested set — matching the Wallet Standard
+    // adapter's `inputsToSign`. `request.from` isn't forwarded: OKX signs with
+    // its single active account, so there's no per-`from` routing. Omitted →
+    // OKX signs all inputs it can.
+    const toSignInputs = request.inputsToSign?.flatMap(input =>
+      input.signingIndexes.map(index => ({
+        index,
+        address: input.address,
+        ...(input.sigHash
+          ? { sighashTypes: [SIGHASH_VALUES[input.sigHash]] }
+          : {})
+      }))
+    )
+    const signedHex = await this.provider.signPsbt(psbtHex, {
+      autoFinalized: false,
+      ...(toSignInputs ? { toSignInputs } : {})
+    })
+    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()
+  })
+})