@meshconnect/uwc-bitcoin 0.2.4-snapshot.ec6b95b → 0.3.0

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.ts

@@ -77,7 +77,23 @@ export interface WalletStandardBitcoinWallet {
 export class WalletStandardBitcoinAdapter implements BitcoinTransportAdapter {
   private accounts: readonly WalletStandardBitcoinAccount[] | null = null
 
-  constructor(private readonly wallet: WalletStandardBitcoinWallet) {}
+  /**
+   * @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']
@@ -153,7 +169,13 @@ export class WalletStandardBitcoinAdapter implements BitcoinTransportAdapter {
     address: string
   ): Promise<WalletStandardBitcoinAccount> {
     if (!this.accounts) await this.getAccounts()
-    const account = this.accounts?.find(a => a.address === address)
+    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',

package/src/bitcoin-namespace.test.ts

@@ -33,6 +33,28 @@ const ethereumNetwork: Network = {
   networkType: 'evm'
 }
 
+/** Same bip122 namespace as Bitcoin, but a different chain id. */
+const dogeNetwork: Network = {
+  internalId: 3,
+  id: 'bip122:1a91e3dace36e2be3bf030a65679fe82',
+  namespace: 'bip122',
+  name: 'Dogecoin',
+  logoUrl: '',
+  nativeCurrency: { name: 'Dogecoin', symbol: 'DOGE', decimals: 8 },
+  networkType: 'dogecoin'
+}
+
+/** Same bip122 namespace as Bitcoin, but a different chain id. */
+const litecoinNetwork: Network = {
+  internalId: 2,
+  id: 'bip122:12a765e31ffd4059bada1e25190f6e98',
+  namespace: 'bip122',
+  name: 'Litecoin',
+  logoUrl: '',
+  nativeCurrency: { name: 'Litecoin', symbol: 'LTC', decimals: 8 },
+  networkType: 'litecoin'
+}
+
 const account: BitcoinAccount = {
   address: 'bc1qexampleaddress',
   publicKey: '02aabbcc',
@@ -66,6 +88,32 @@ describe('assertBitcoinNetwork', () => {
       ethereumNetwork.id
     )
   })
+
+  it('throws a distinct error for a bip122 network that is not Bitcoin mainnet (Dogecoin)', () => {
+    expect(() => assertBitcoinNetwork(dogeNetwork, 'test')).toThrow(
+      WalletConnectorError
+    )
+    expect(() => assertBitcoinNetwork(dogeNetwork, 'test')).toThrow(
+      dogeNetwork.id
+    )
+    // Distinct from the namespace-mismatch message — callers must be able to
+    // tell "wrong namespace" apart from "right namespace, wrong chain".
+    expect(() => assertBitcoinNetwork(dogeNetwork, 'test')).toThrow(
+      /unsupported bip122 chain/
+    )
+    expect(() => assertBitcoinNetwork(ethereumNetwork, 'test')).not.toThrow(
+      /unsupported bip122 chain/
+    )
+  })
+
+  it('throws a distinct error for a bip122 network that is not Bitcoin mainnet (Litecoin)', () => {
+    expect(() => assertBitcoinNetwork(litecoinNetwork, 'test')).toThrow(
+      WalletConnectorError
+    )
+    expect(() => assertBitcoinNetwork(litecoinNetwork, 'test')).toThrow(
+      /unsupported bip122 chain/
+    )
+  })
 })
 
 describe('BitcoinNamespace', () => {
@@ -90,6 +138,17 @@ describe('BitcoinNamespace', () => {
     ).toThrow(WalletConnectorError)
   })
 
+  it('assertSupportedNetwork rejects other bip122 chains (Dogecoin, Litecoin)', () => {
+    expect(() =>
+      new BitcoinNamespace(fakeAdapter()).assertSupportedNetwork(dogeNetwork)
+    ).toThrow(WalletConnectorError)
+    expect(() =>
+      new BitcoinNamespace(fakeAdapter()).assertSupportedNetwork(
+        litecoinNetwork
+      )
+    ).toThrow(WalletConnectorError)
+  })
+
   it('delegates getAccounts to the adapter', async () => {
     const adapter = fakeAdapter()
     const result = await new BitcoinNamespace(adapter).getAccounts()

package/src/bitcoin-namespace.ts

@@ -8,6 +8,7 @@ import type {
   SignatureType,
   TransactionResult
 } from '@meshconnect/uwc-types'
+import { bitcoinNetwork } from '@meshconnect/uwc-constants'
 import { WalletConnectorError } from '@meshconnect/uwc-types'
 import type { BitcoinTransportAdapter } from './adapter'
 
@@ -15,8 +16,13 @@ import type { BitcoinTransportAdapter } from './adapter'
 export const BITCOIN_NAMESPACE: Namespace = 'bip122'
 
 /**
- * Assert `network` is a bip122 network, else throw. Shared by the namespace
- * module and its transport adapters so the boundary check lives in one place.
+ * Assert `network` is the bip122 network this module actually supports
+ * (Bitcoin mainnet), else throw. Other bip122 chains (Dogecoin, Litecoin,
+ * etc.) share the namespace but differ in chain id — accepting them here
+ * would let a Bitcoin-only wallet silently return a Bitcoin address stamped
+ * with the wrong network id, so they must be rejected explicitly rather than
+ * only checking the namespace. Shared by the namespace module and its
+ * transport adapters so the boundary check lives in one place.
  */
 export function assertBitcoinNetwork(network: Network, method: string): void {
   if (network.namespace !== BITCOIN_NAMESPACE) {
@@ -25,6 +31,12 @@ export function assertBitcoinNetwork(network: Network, method: string): void {
       message: `${method}: expected a bip122 network but got "${network.id}"`
     })
   }
+  if (network.id !== bitcoinNetwork.id) {
+    throw new WalletConnectorError({
+      type: 'unknown',
+      message: `${method}: unsupported bip122 chain "${network.id}" — only Bitcoin mainnet ("${bitcoinNetwork.id}") is supported`
+    })
+  }
 }
 
 /**

package/src/encoding.ts

@@ -27,3 +27,21 @@ export function base64ToBytes(base64: string): Uint8Array {
   for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
   return bytes
 }
+
+export function hexToBytes(hex: string): Uint8Array {
+  const clean = /^0x/i.test(hex) ? hex.slice(2) : hex
+  if (clean.length % 2 !== 0) {
+    throw new Error('hexToBytes: odd-length hex string')
+  }
+  // Validate before parsing: `parseInt` on a non-hex pair yields NaN, which a
+  // Uint8Array silently coerces to 0 — so bad input would corrupt data (a PSBT
+  // or public key) instead of failing fast. Reject it.
+  if (!/^[0-9a-fA-F]*$/.test(clean)) {
+    throw new Error('hexToBytes: non-hex characters')
+  }
+  const bytes = new Uint8Array(clean.length / 2)
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16)
+  }
+  return bytes
+}

package/src/index.ts

@@ -9,5 +9,6 @@ export type {
   WalletStandardBitcoinWallet,
   WalletStandardBitcoinAccount
 } from './adapters/wallet-standard'
-export { WalletConnectBitcoinAdapter } from './adapters/walletconnect'
-export type { BitcoinWalletConnectRequest } from './adapters/walletconnect'
+export { OkxBitcoinAdapter } from './adapters/okx'
+export type { OkxBitcoinProvider } from './adapters/okx'
+export { bytesToHex, hexToBytes } from './encoding'

package/dist/adapters/walletconnect.d.ts

@@ -1,36 +0,0 @@
-import type { BitcoinAccount, BitcoinPsbtSignRequest, BitcoinSendTransferRequest, BitcoinSignMessageParams, SignatureType, TransactionResult } from '@meshconnect/uwc-types';
-import type { BitcoinTransportAdapter } from '../adapter';
-/**
- * Issues a WalletConnect JSON-RPC request for a bip122 method. The WalletConnect
- * transport binds this to its live `SignClient` + session topic + chainId, e.g.
- * `(method, params) => signClient.request({ topic, chainId, request: { method, params } })`.
- * Kept as a plain function so `uwc-bitcoin` needs no `@walletconnect/*` dependency.
- */
-export type BitcoinWalletConnectRequest = (method: string, params: Record<string, unknown>) => Promise<unknown>;
-/**
- * WalletConnect (bip122) transport adapter — the Path A / mobile path (Trust
- * Wallet, …). The WalletConnect transport pairs the session and constructs this
- * adapter bound to the connected account's first external address plus a
- * `request` function; this adapter maps our domain shapes onto the Reown/CAIP-2
- * bip122 JSON-RPC methods (`getAccountAddresses`, `signMessage`, `signPsbt`,
- * `sendTransfer`).
- *
- * Wire format follows the Reown Bitcoin RPC reference (what wallets implement
- * over WalletConnect) — all-JSON strings, `account` on every request. NOTE:
- * untested end-to-end; grounded on the spec, not a live wallet.
- */
-export declare class WalletConnectBitcoinAdapter implements BitcoinTransportAdapter {
-    private readonly account;
-    private readonly request;
-    /**
-     * @param account The connected account's first external address — the
-     *   `account` parameter every bip122 method requires.
-     * @param request Issues the bound WalletConnect JSON-RPC request.
-     */
-    constructor(account: string, request: BitcoinWalletConnectRequest);
-    getAccounts(): Promise<BitcoinAccount[]>;
-    signMessage(params: BitcoinSignMessageParams): Promise<SignatureType>;
-    signPsbt(request: BitcoinPsbtSignRequest): Promise<string>;
-    sendTransfer(request: BitcoinSendTransferRequest): Promise<TransactionResult>;
-}
-//# sourceMappingURL=walletconnect.d.ts.map

package/dist/adapters/walletconnect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"walletconnect.d.ts","sourceRoot":"","sources":["../../src/adapters/walletconnect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,0BAA0B,EAE1B,wBAAwB,EACxB,aAAa,EACb,iBAAiB,EAClB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC5B,OAAO,CAAC,OAAO,CAAC,CAAA;AAmBrB;;;;;;;;;;;GAWG;AACH,qBAAa,2BAA4B,YAAW,uBAAuB;IAOvE,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B;;;;OAIG;gBAEgB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,2BAA2B;IAGjD,WAAW,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAgBxC,WAAW,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,aAAa,CAAC;IAUrE,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B1D,YAAY,CAChB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,iBAAiB,CAAC;CAQ9B"}

package/dist/adapters/walletconnect.js

@@ -1,90 +0,0 @@
-import { WalletConnectorError } from '@meshconnect/uwc-types';
-/** Maps a SIGHASH flag to its numeric value (Bitcoin Core encoding). */
-const SIGHASH_VALUES = {
-    ALL: 0x01,
-    NONE: 0x02,
-    SINGLE: 0x03,
-    'ALL|ANYONECANPAY': 0x81,
-    'NONE|ANYONECANPAY': 0x82,
-    'SINGLE|ANYONECANPAY': 0x83
-};
-/**
- * WalletConnect (bip122) transport adapter — the Path A / mobile path (Trust
- * Wallet, …). The WalletConnect transport pairs the session and constructs this
- * adapter bound to the connected account's first external address plus a
- * `request` function; this adapter maps our domain shapes onto the Reown/CAIP-2
- * bip122 JSON-RPC methods (`getAccountAddresses`, `signMessage`, `signPsbt`,
- * `sendTransfer`).
- *
- * Wire format follows the Reown Bitcoin RPC reference (what wallets implement
- * over WalletConnect) — all-JSON strings, `account` on every request. NOTE:
- * untested end-to-end; grounded on the spec, not a live wallet.
- */
-export class WalletConnectBitcoinAdapter {
-    account;
-    request;
-    /**
-     * @param account The connected account's first external address — the
-     *   `account` parameter every bip122 method requires.
-     * @param request Issues the bound WalletConnect JSON-RPC request.
-     */
-    constructor(account, request) {
-        this.account = account;
-        this.request = request;
-    }
-    async getAccounts() {
-        const result = (await this.request('getAccountAddresses', {
-            account: this.account
-        }));
-        return result.map(entry => ({
-            address: entry.address,
-            // WalletConnect wallets MAY omit the public key; empty when absent.
-            publicKey: entry.publicKey ?? '',
-            ...(entry.intention === 'ordinal'
-                ? { purpose: 'ordinals' }
-                : entry.intention === 'payment'
-                    ? { purpose: 'payment' }
-                    : {})
-        }));
-    }
-    async signMessage(params) {
-        const result = (await this.request('signMessage', {
-            account: this.account,
-            message: params.message,
-            address: params.account.address,
-            ...(params.protocol ? { protocol: params.protocol } : {})
-        }));
-        return { type: 'standard', signature: result.signature };
-    }
-    async signPsbt(request) {
-        if (!request.inputsToSign?.length) {
-            throw new WalletConnectorError({
-                type: 'unknown',
-                message: 'walletconnect bitcoin: signPsbt requires inputsToSign (the WC signPsbt method has no "sign all" mode)'
-            });
-        }
-        const signInputs = request.inputsToSign.flatMap(input => input.signingIndexes.map(index => ({
-            address: input.address,
-            index,
-            ...(input.sigHash
-                ? { sighashTypes: [SIGHASH_VALUES[input.sigHash]] }
-                : {})
-        })));
-        const result = (await this.request('signPsbt', {
-            account: this.account,
-            psbt: request.psbt,
-            signInputs,
-            broadcast: false
-        }));
-        return result.psbt;
-    }
-    async sendTransfer(request) {
-        const result = (await this.request('sendTransfer', {
-            account: this.account,
-            recipientAddress: request.to,
-            amount: request.amount.toString()
-        }));
-        return result.txid;
-    }
-}
-//# sourceMappingURL=walletconnect.js.map

package/dist/adapters/walletconnect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"walletconnect.js","sourceRoot":"","sources":["../../src/adapters/walletconnect.ts"],"names":[],"mappings":"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"}

package/src/adapters/walletconnect.test.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { WalletConnectorError } from '@meshconnect/uwc-types'
-import { WalletConnectBitcoinAdapter } from './walletconnect'
-
-const ACCOUNT = 'bc1qsender'
-
-describe('WalletConnectBitcoinAdapter', () => {
-  it('getAccounts calls getAccountAddresses and maps intention -> purpose', async () => {
-    const request = vi.fn().mockResolvedValue([
-      { address: 'bc1qpay', publicKey: '02aa', intention: 'payment' },
-      { address: 'bc1qord', intention: 'ordinal' }
-    ])
-    const adapter = new WalletConnectBitcoinAdapter(ACCOUNT, request)
-
-    const accounts = await adapter.getAccounts()
-
-    expect(request).toHaveBeenCalledWith('getAccountAddresses', {
-      account: ACCOUNT
-    })
-    expect(accounts).toEqual([
-      { address: 'bc1qpay', publicKey: '02aa', purpose: 'payment' },
-      { address: 'bc1qord', publicKey: '', purpose: 'ordinals' }
-    ])
-  })
-
-  it('signMessage passes account + address + raw message and wraps the signature', async () => {
-    const request = vi.fn().mockResolvedValue({ signature: 'sigbase64' })
-    const adapter = new WalletConnectBitcoinAdapter(ACCOUNT, request)
-
-    const sig = await adapter.signMessage({
-      account: { address: 'bc1qpay', publicKey: '02aa' },
-      message: 'verify me',
-      protocol: 'bip322'
-    })
-
-    expect(request).toHaveBeenCalledWith('signMessage', {
-      account: ACCOUNT,
-      message: 'verify me',
-      address: 'bc1qpay',
-      protocol: 'bip322'
-    })
-    expect(sig).toEqual({ type: 'standard', signature: 'sigbase64' })
-  })
-
-  it('signPsbt flattens inputsToSign per index and maps SIGHASH to numbers', async () => {
-    const request = vi.fn().mockResolvedValue({ psbt: 'signedpsbt' })
-    const adapter = new WalletConnectBitcoinAdapter(ACCOUNT, request)
-
-    const signed = await adapter.signPsbt({
-      from: 'bc1qpay',
-      psbt: 'cHNidP8=',
-      inputsToSign: [
-        {
-          address: 'bc1qpay',
-          signingIndexes: [0, 2],
-          sigHash: 'ALL|ANYONECANPAY'
-        }
-      ]
-    })
-
-    expect(request).toHaveBeenCalledWith('signPsbt', {
-      account: ACCOUNT,
-      psbt: 'cHNidP8=',
-      signInputs: [
-        { address: 'bc1qpay', index: 0, sighashTypes: [0x81] },
-        { address: 'bc1qpay', index: 2, sighashTypes: [0x81] }
-      ],
-      broadcast: false
-    })
-    expect(signed).toBe('signedpsbt')
-  })
-
-  it('signPsbt rejects when inputsToSign is missing (WC has no sign-all mode)', async () => {
-    const adapter = new WalletConnectBitcoinAdapter(ACCOUNT, vi.fn())
-    await expect(
-      adapter.signPsbt({ from: 'bc1qpay', psbt: 'cHNidP8=' })
-    ).rejects.toBeInstanceOf(WalletConnectorError)
-  })
-
-  it('sendTransfer maps to recipientAddress + amount string and returns the txid', async () => {
-    const request = vi.fn().mockResolvedValue({ txid: 'deadbeef' })
-    const adapter = new WalletConnectBitcoinAdapter(ACCOUNT, request)
-
-    const txid = await adapter.sendTransfer({
-      from: 'bc1qpay',
-      to: 'bc1qdest',
-      amount: 100000n
-    })
-
-    expect(request).toHaveBeenCalledWith('sendTransfer', {
-      account: ACCOUNT,
-      recipientAddress: 'bc1qdest',
-      amount: '100000'
-    })
-    expect(txid).toBe('deadbeef')
-  })
-})