@meshconnect/uwc-bitcoin 0.4.1 → 0.4.3-snapshot.2fa10fc

package/src/bitcoin-namespace.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest'
+import { describe, it, expect, vi, afterEach } from 'vitest'
 import type {
   BitcoinAccount,
   BitcoinSignMessageParams,
@@ -207,6 +207,70 @@ describe('BitcoinNamespace', () => {
     expect(result).toBe('c2lnbmVk')
   })
 
+  describe('signAndSendPsbt', () => {
+    // Wallet-signed, already-finalized P2WPKH PSBT and the tx it extracts to
+    // (bitcoinjs-lib reference output; full coverage lives in psbt.test.ts).
+    const SIGNED =
+      'cHNidP8BAHECAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABAR+AOAEAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDAQhrAkcwRAIgb6l7rI+g7Z79v+ZrhhfyHJQdQE5d92QS85f76ysSLqwCIBDgQmiFXUfEN79dj4CMid5jIiIWebHuQnREy+jWfC3vASEDG4TFVnsSZECZXT7VqroFZdceGDRgSBn/nBf16dXdB48AAAA='
+    const RAW_TX =
+      '0200000000010101010101010101010101010101010101010101010101010101010101010101010000000000fdffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b2359830247304402206fa97bac8fa0ed9efdbfe66b8617f21c941d404e5df76412f397fbeb2b122eac022010e04268855d47c437bf5d8f808c89de6322221679b1ee427444cbe8d67c2def0121031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f50f80c00'
+    const TXID =
+      '49274930c45612befb7a6f0b9d73e19e81322e6aefa8effc764cf6177d21f126'
+    const request = { from: 'bc1qexampleaddress', psbt: 'cHNidA==' }
+
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('signs, finalizes, and broadcasts to the given endpoint, returning the txid', async () => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValue(new Response(TXID, { status: 200 }))
+      vi.stubGlobal('fetch', fetchMock)
+      const adapter = {
+        ...fakeAdapter(),
+        signPsbt: vi.fn().mockResolvedValue(SIGNED)
+      }
+
+      const txid = await new BitcoinNamespace(adapter).signAndSendPsbt(
+        request,
+        'https://esplora.example/api'
+      )
+
+      expect(adapter.signPsbt).toHaveBeenCalledWith(request)
+      expect(fetchMock).toHaveBeenCalledWith(
+        'https://esplora.example/api/tx',
+        expect.objectContaining({ body: RAW_TX })
+      )
+      expect(txid).toBe(TXID)
+    })
+
+    it('does not broadcast when the wallet rejects signing', async () => {
+      const fetchMock = vi.fn()
+      vi.stubGlobal('fetch', fetchMock)
+      const adapter = {
+        ...fakeAdapter(),
+        signPsbt: vi.fn().mockRejectedValue(new Error('User rejected'))
+      }
+
+      await expect(
+        new BitcoinNamespace(adapter).signAndSendPsbt(request)
+      ).rejects.toThrow('User rejected')
+      expect(fetchMock).not.toHaveBeenCalled()
+    })
+
+    it('does not broadcast a PSBT that cannot be finalized', async () => {
+      const fetchMock = vi.fn()
+      vi.stubGlobal('fetch', fetchMock)
+      const adapter = fakeAdapter() // returns a non-PSBT string
+
+      await expect(
+        new BitcoinNamespace(adapter).signAndSendPsbt(request)
+      ).rejects.toBeInstanceOf(WalletConnectorError)
+      expect(fetchMock).not.toHaveBeenCalled()
+    })
+  })
+
   it('delegates sendTransfer to the adapter', async () => {
     const adapter = fakeAdapter()
     const request = { from: 'bc1qexampleaddress', to: 'bc1qdest', amount: 1000 }

package/src/bitcoin-namespace.ts

@@ -11,6 +11,9 @@ import type {
 import { bitcoinNetwork } from '@meshconnect/uwc-constants'
 import { WalletConnectorError } from '@meshconnect/uwc-types'
 import type { BitcoinTransportAdapter } from './adapter'
+import { broadcastTransaction } from './broadcast'
+import { base64ToBytes } from './encoding'
+import { finalizePsbt } from './psbt'
 
 /** CAIP-2 namespace this module serves. */
 export const BITCOIN_NAMESPACE: Namespace = 'bip122'
@@ -51,10 +54,11 @@ export function assertBitcoinNetwork(network: Network, method: string): void {
  * was constructed with — the transport builds that adapter bound to the live
  * session.
  *
- * Phase 2 exposes the grounded verify-flow operations (account enumeration and
- * message signing). PSBT signing (Path B) plus finalize/broadcast, and the
- * high-level `sendTransfer` (Path A), land in Phase 3 alongside their concrete
- * adapters.
+ * Sending is Mesh-broadcast: the wallet only signs a Mesh-built PSBT, and this
+ * module finalizes and broadcasts it ({@link signAndSendPsbt}). Wallet-side
+ * broadcast can't be the primary path — framed Link's bridge relays only
+ * `bitcoin:signTransaction`, and some wallets (Bitget) expose no working
+ * broadcast at all.
  *
  * Phased build plan:
  * https://app.notion.com/p/3a5f862e950a8187b3d3f0e255d13f45
@@ -90,6 +94,20 @@ export class BitcoinNamespace {
     return this.adapter.signPsbt(request)
   }
 
+  /**
+   * Sign a PSBT with the wallet, finalize it, and broadcast the result through
+   * the Esplora API at `broadcastUrl` (mempool.space when omitted). Returns the
+   * txid — the same shape every other namespace returns from a send.
+   */
+  async signAndSendPsbt(
+    request: BitcoinPsbtSignRequest,
+    broadcastUrl?: string
+  ): Promise<TransactionResult> {
+    const signed = await this.signPsbt(request)
+    const rawTx = finalizePsbt(base64ToBytes(signed))
+    return broadcastTransaction(rawTx, broadcastUrl)
+  }
+
   /**
    * High-level transfer (Path A): the wallet signs and broadcasts, returning a
    * txid. Rejects if the active adapter's transport does not offer it.

package/src/broadcast.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import { broadcastTransaction } from './broadcast'
+
+// P2WPKH raw tx and its txid (bitcoinjs-lib reference, see psbt.test.ts).
+const RAW_TX =
+  '0200000000010101010101010101010101010101010101010101010101010101010101010101010000000000fdffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b2359830247304402206fa97bac8fa0ed9efdbfe66b8617f21c941d404e5df76412f397fbeb2b122eac022010e04268855d47c437bf5d8f808c89de6322221679b1ee427444cbe8d67c2def0121031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f50f80c00'
+const TXID = '49274930c45612befb7a6f0b9d73e19e81322e6aefa8effc764cf6177d21f126'
+
+function stubFetch(body: string, status = 200) {
+  const fetchMock = vi.fn().mockResolvedValue(new Response(body, { status }))
+  vi.stubGlobal('fetch', fetchMock)
+  return fetchMock
+}
+
+describe('broadcastTransaction', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('POSTs the raw hex to mempool.space by default and returns the txid', async () => {
+    const fetchMock = stubFetch(TXID)
+
+    await expect(broadcastTransaction(RAW_TX)).resolves.toBe(TXID)
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://mempool.space/api/tx',
+      expect.objectContaining({
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+        body: RAW_TX,
+        signal: expect.any(AbortSignal)
+      })
+    )
+  })
+
+  it('uses a custom Esplora base URL, tolerating a trailing slash', async () => {
+    const fetchMock = stubFetch(TXID)
+
+    await broadcastTransaction(RAW_TX, 'https://esplora.example/api/')
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://esplora.example/api/tx',
+      expect.anything()
+    )
+  })
+
+  it('accepts the txid with whitespace or upper case', async () => {
+    stubFetch(`${TXID.toUpperCase()}\n`)
+
+    await expect(broadcastTransaction(RAW_TX)).resolves.toBe(TXID)
+  })
+
+  it('throws with the API error message on a non-2xx response', async () => {
+    stubFetch(
+      'sendrawtransaction RPC error: {"code":-26,"message":"min relay fee not met"}',
+      400
+    )
+
+    const error = await broadcastTransaction(RAW_TX).catch(e => e)
+    expect(error).toBeInstanceOf(WalletConnectorError)
+    expect(error.message).toContain('(400)')
+    expect(error.message).toContain('min relay fee not met')
+  })
+
+  // A retry after a lost response: the network already holds this exact tx.
+  it.each([
+    'sendrawtransaction RPC error: {"code":-27,"message":"Transaction already in block chain"}',
+    'sendrawtransaction RPC error: {"code":-27,"message":"Transaction outputs already in utxo set"}',
+    'sendrawtransaction RPC error: {"code":-26,"message":"txn-already-known"}',
+    'sendrawtransaction RPC error: {"code":-26,"message":"txn-already-in-mempool"}'
+  ])(
+    'resolves with the local txid when the tx is already broadcast: %s',
+    async body => {
+      stubFetch(body, 400)
+
+      await expect(broadcastTransaction(RAW_TX)).resolves.toBe(TXID)
+    }
+  )
+
+  it('throws on a 2xx whose body is not this txid', async () => {
+    stubFetch('<html>maintenance</html>')
+
+    await expect(broadcastTransaction(RAW_TX)).rejects.toThrow(
+      `expected txid ${TXID}`
+    )
+  })
+
+  it('throws on a 2xx carrying a different txid', async () => {
+    stubFetch('ff'.repeat(32))
+
+    await expect(broadcastTransaction(RAW_TX)).rejects.toThrow(
+      WalletConnectorError
+    )
+  })
+
+  it('names the txid when a network failure leaves the outcome unknown', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new TypeError('offline')))
+
+    const error = await broadcastTransaction(RAW_TX).catch(e => e)
+    expect(error).toBeInstanceOf(WalletConnectorError)
+    expect(error.message).toContain('outcome unknown')
+    expect(error.message).toContain(TXID)
+    expect(error.message).toContain('offline')
+  })
+
+  // Timing out after signing must not read as a failed payment: the tx may
+  // already be on the network, so the error has to carry the txid.
+  it('names the txid when the 30s timeout aborts the request', async () => {
+    const controller = new AbortController()
+    const timeoutSpy = vi
+      .spyOn(AbortSignal, 'timeout')
+      .mockReturnValue(controller.signal)
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(
+        (_url: string, init: RequestInit) =>
+          new Promise((_resolve, reject) => {
+            // Like real fetch: reject at once if the signal is already aborted.
+            if (init.signal?.aborted) reject(init.signal.reason)
+            init.signal?.addEventListener('abort', () =>
+              reject(init.signal?.reason)
+            )
+          })
+      )
+    )
+
+    const pending = broadcastTransaction(RAW_TX).catch(e => e)
+    controller.abort(new DOMException('signal timed out', 'TimeoutError'))
+    const error = await pending
+
+    expect(timeoutSpy).toHaveBeenCalledWith(30_000)
+    expect(error).toBeInstanceOf(WalletConnectorError)
+    expect(error.message).toContain('outcome unknown')
+    expect(error.message).toContain(TXID)
+    expect(error.message).toContain('signal timed out')
+    timeoutSpy.mockRestore()
+  })
+})

package/src/broadcast.ts

@@ -0,0 +1,75 @@
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import { computeTxid } from './psbt'
+
+/** mempool.space's Esplora API for Bitcoin mainnet. */
+export const DEFAULT_BITCOIN_BROADCAST_URL = 'https://mempool.space/api'
+
+const BROADCAST_TIMEOUT_MS = 30_000
+
+/**
+ * Bitcoin Core rejection reasons meaning the network already has this exact
+ * transaction — e.g. a retry after a lost response. Same txid, so it succeeded.
+ * A confirmed tx reads "already in block chain" before Core 24 and "outputs
+ * already in utxo set" from 24 on; nodes behind an Esplora host vary.
+ */
+const ALREADY_BROADCAST =
+  /txn-already-known|txn-already-in-mempool|already in block ?chain|outputs already in utxo set/i
+
+/**
+ * Broadcast a raw transaction through an Esplora-compatible REST API
+ * (`POST {baseUrl}/tx`, raw hex body, txid as the plain-text response) and
+ * return the txid.
+ *
+ * `baseUrl` is any Esplora host — mempool.space by default, or a proxy with
+ * the same contract — so moving broadcast behind a Mesh endpoint is a config
+ * change, not a code change.
+ *
+ * The txid is computed locally first, because a thrown broadcast is not proof
+ * the payment failed:
+ * - "already known" means an earlier attempt landed, so it resolves with the
+ *   txid instead of reporting a payment that went through as failed;
+ * - a lost response or timeout leaves the outcome unknown, so the error names
+ *   the txid for the caller to reconcile against the chain;
+ * - a response that isn't this txid throws rather than being recorded as one.
+ *
+ * Any other non-2xx throws with the API's own message (e.g. `min relay fee not
+ * met`): the payment did not happen, and the reason is what makes it actionable.
+ */
+export async function broadcastTransaction(
+  rawTxHex: string,
+  baseUrl: string = DEFAULT_BITCOIN_BROADCAST_URL
+): Promise<string> {
+  const txid = await computeTxid(rawTxHex)
+
+  let response: Response
+  let body: string
+  try {
+    response = await fetch(`${baseUrl.replace(/\/+$/, '')}/tx`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: rawTxHex,
+      signal: AbortSignal.timeout(BROADCAST_TIMEOUT_MS)
+    })
+    body = (await response.text()).trim()
+  } catch (error) {
+    throw new WalletConnectorError({
+      type: 'unknown',
+      message: `Bitcoin broadcast outcome unknown for txid ${txid}: ${error instanceof Error ? error.message : String(error)}`
+    })
+  }
+
+  if (!response.ok) {
+    if (ALREADY_BROADCAST.test(body)) return txid
+    throw new WalletConnectorError({
+      type: 'unknown',
+      message: `Bitcoin broadcast failed (${response.status}): ${body || response.statusText}`
+    })
+  }
+  if (body.toLowerCase() !== txid) {
+    throw new WalletConnectorError({
+      type: 'unknown',
+      message: `Bitcoin broadcast returned ${body.slice(0, 200) || 'an empty response'}, expected txid ${txid}`
+    })
+  }
+  return txid
+}

package/src/index.ts

@@ -11,4 +11,14 @@ export type {
 } from './adapters/wallet-standard'
 export { OkxBitcoinAdapter } from './adapters/okx'
 export type { OkxBitcoinProvider } from './adapters/okx'
-export { bytesToHex, hexToBytes } from './encoding'
+export {
+  bytesToHex,
+  hexToBytes,
+  base64ToBytes,
+  bytesToBase64
+} from './encoding'
+export { finalizePsbt, computeTxid } from './psbt'
+export {
+  broadcastTransaction,
+  DEFAULT_BITCOIN_BROADCAST_URL
+} from './broadcast'

package/src/psbt.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest'
+import { WalletConnectorError } from '@meshconnect/uwc-types'
+import { computeTxid, finalizePsbt } from './psbt'
+import { base64ToBytes } from './encoding'
+
+// Generated once with bitcoinjs-lib 6 (finalizeAllInputs + extractTransaction)
+// from deterministic test keys — the reference output this finalizer must match.
+const FIXTURES = {
+  p2wpkh: {
+    signed:
+      'cHNidP8BAHECAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABAR+AOAEAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDIgIDG4TFVnsSZECZXT7VqroFZdceGDRgSBn/nBf16dXdB49HMEQCIG+pe6yPoO2e/b/ma4YX8hyUHUBOXfdkEvOX++srEi6sAiAQ4EJohV1HxDe/XY+AjIneYyIiFnmx7kJ0RMvo1nwt7wEAAAA=',
+    finalized:
+      'cHNidP8BAHECAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABAR+AOAEAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDAQhrAkcwRAIgb6l7rI+g7Z79v+ZrhhfyHJQdQE5d92QS85f76ysSLqwCIBDgQmiFXUfEN79dj4CMid5jIiIWebHuQnREy+jWfC3vASEDG4TFVnsSZECZXT7VqroFZdceGDRgSBn/nBf16dXdB48AAAA=',
+    rawTx:
+      '0200000000010101010101010101010101010101010101010101010101010101010101010101010000000000fdffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b2359830247304402206fa97bac8fa0ed9efdbfe66b8617f21c941d404e5df76412f397fbeb2b122eac022010e04268855d47c437bf5d8f808c89de6322221679b1ee427444cbe8d67c2def0121031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f50f80c00',
+    txid: '49274930c45612befb7a6f0b9d73e19e81322e6aefa8effc764cf6177d21f126'
+  },
+  p2tr: {
+    signed:
+      'cHNidP8BAHECAAAAAQICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAQAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABASuAOAEAAAAAACJRIKZ0wrFSo4MSax4qOgaD6wek1laJg6c9+ybewqep+wZDARNAIr2m4yiSX+7SBh7qguPdpLdemKfqEvKbVVFtzKPC7TE+NHCTqHQ7ODSaZISBp33swcaDcf0sIjzami69OMCgtQEXIE1LbNE2EDLKm9KuudkAqk1F2erYCslCM3TEUaclTQdmAAAA',
+    finalized:
+      'cHNidP8BAHECAAAAAQICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAQAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABASuAOAEAAAAAACJRIKZ0wrFSo4MSax4qOgaD6wek1laJg6c9+ybewqep+wZDAQhCAUAivabjKJJf7tIGHuqC492kt16Yp+oS8ptVUW3Mo8LtMT40cJOodDs4NJpkhIGnfezBxoNx/SwiPNqaLr04wKC1AAAA',
+    rawTx:
+      '0200000000010102020202020202020202020202020202020202020202020202020202020202020100000000fdffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b235983014022bda6e328925feed2061eea82e3dda4b75e98a7ea12f29b55516dcca3c2ed313e347093a8743b38349a648481a77decc1c68371fd2c223cda9a2ebd38c0a0b550f80c00',
+    txid: 'a38a1578f26624da7b3e2d4f60f45b95eac701475e30ebbfbc241fea7d854c09'
+  },
+  p2pkh: {
+    signed:
+      'cHNidP8BAHECAAAAAfJ1cvry7cFk+E7symofVIqxUXjtwRT5QTErVGi6Vl2pAAAAAAD/////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABAFUCAAAAAaqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqAAAAAAD/////AYA4AQAAAAAAGXapFEF9S+kNNTYyZ7jyr6/JUxERxBrkiKwAAAAAIgICUx/mBoE0UD0nIxMyJ8hnrI+myDxTfppEw8W9vcsf4zdHMEQCICO2869Iqe86cT9EmLXZiWp5I5XtnEoghepLEBmvti9qAiB7gWZU0DVeJSA4T+0uDnPQzZDjtgi6FT0NKPuPKDz/VgEAAAA=',
+    finalized:
+      'cHNidP8BAHECAAAAAfJ1cvry7cFk+E7symofVIqxUXjtwRT5QTErVGi6Vl2pAAAAAAD/////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABAFUCAAAAAaqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqAAAAAAD/////AYA4AQAAAAAAGXapFEF9S+kNNTYyZ7jyr6/JUxERxBrkiKwAAAAAAQdqRzBEAiAjtvOvSKnvOnE/RJi12YlqeSOV7ZxKIIXqSxAZr7YvagIge4FmVNA1XiUgOE/tLg5z0M2Q47YIuhU9DSj7jyg8/1YBIQJTH+YGgTRQPScjEzInyGesj6bIPFN+mkTDxb29yx/jNwAAAA==',
+    rawTx:
+      '0200000001f27572faf2edc164f84eecca6a1f548ab15178edc114f941312b5468ba565da9000000006a473044022023b6f3af48a9ef3a713f4498b5d9896a792395ed9c4a2085ea4b1019afb62f6a02207b816654d0355e2520384fed2e0e73d0cd90e3b608ba153d0d28fb8f283cff56012102531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337ffffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b23598350f80c00',
+    txid: 'ae8e9b1f06212108c68cdeab38317301f89863e2ae7154ecf719b7a54591f7dd'
+  },
+  'p2sh-p2wpkh': {
+    signed:
+      'cHNidP8BAHECAAAAAQQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAgAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABASCAOAEAAAAAABepFEoatoZPIlugnDDXf3ql2fVQWAH7hyICA0Ynea1KrTlRRhR1GnEIXy8Q4celk+TgMO+1uHIc5VsLSDBFAiEAmKvSJoND+fkDu5PqlPjnT+x3kWLp4BFZpeXVPvwDyHECIFEtIQrxyBPsmirPem3QIMhu9RPl9UT3EKgMBKVSlnGKAQEEFgAUiI2715mPn4DU+CtPnObViC8xCuwAAAA=',
+    finalized:
+      'cHNidP8BAHECAAAAAQQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAgAAAAD9////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABASCAOAEAAAAAABepFEoatoZPIlugnDDXf3ql2fVQWAH7hwEHFxYAFIiNu9eZj5+A1PgrT5zm1YgvMQrsAQhsAkgwRQIhAJir0iaDQ/n5A7uT6pT450/sd5Fi6eARWaXl1T78A8hxAiBRLSEK8cgT7Joqz3pt0CDIbvUT5fVE9xCoDASlUpZxigEhA0Ynea1KrTlRRhR1GnEIXy8Q4celk+TgMO+1uHIc5VsLAAAA',
+    rawTx:
+      '0200000000010104040404040404040404040404040404040404040404040404040404040404040200000017160014888dbbd7998f9f80d4f82b4f9ce6d5882f310aecfdffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b2359830248304502210098abd2268343f9f903bb93ea94f8e74fec779162e9e01159a5e5d53efc03c8710220512d210af1c813ec9a2acf7a6dd020c86ef513e5f544f710a80c04a55296718a012103462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b50f80c00',
+    txid: '20669172342d160723aed87b22b753ce37790a65b621001ccff8fae36a3cc7f9'
+  },
+  mixed: {
+    signed:
+      'cHNidP8BAJoCAAAAAgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAAAAAD9////EXOuCENnqp7HHdzQHK4AG91XoN02XQrgdv+C/AjdBBgAAAAAAP3///8CUMMAAAAAAAAWABRnDKp55R147QxYO4n/OdnEm3GZ50hxAAAAAAAAFgAUebAAiHYmspSpFFAaTNImtYsjWYNQ+AwAAAEBH0CcAAAAAAAAFgAUebAAiHYmspSpFFAaTNImtYsjWYMiAgMbhMVWexJkQJldPtWqugVl1x4YNGBIGf+cF/Xp1d0Hj0gwRQIhAP0OSqBZqIdg68dvrgSimKyawqTSoEdwEDMNiF0htY1OAiAX9Qcf+6FsQ6PAd1a8WAocqKZSc3UY8Z5DkldGlMgq7gEAAQBVAgAAAAGqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqgAAAAAA/////wFAnAAAAAAAABl2qRRBfUvpDTU2Mme48q+vyVMREcQa5IisAAAAACICAlMf5gaBNFA9JyMTMifIZ6yPpsg8U36aRMPFvb3LH+M3SDBFAiEAvSZyO8/TxyX1YlNx/zRKT6M/47IcnP+YaZYrnV14KDMCIAlPeu87PznpRl4RxtzCml1pVZionjFti4Gu9C+h8ZZxAQAAAA==',
+    finalized:
+      'cHNidP8BAJoCAAAAAgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFAAAAAAD9////EXOuCENnqp7HHdzQHK4AG91XoN02XQrgdv+C/AjdBBgAAAAAAP3///8CUMMAAAAAAAAWABRnDKp55R147QxYO4n/OdnEm3GZ50hxAAAAAAAAFgAUebAAiHYmspSpFFAaTNImtYsjWYNQ+AwAAAEBH0CcAAAAAAAAFgAUebAAiHYmspSpFFAaTNImtYsjWYMBCGwCSDBFAiEA/Q5KoFmoh2Drx2+uBKKYrJrCpNKgR3AQMw2IXSG1jU4CIBf1Bx/7oWxDo8B3VrxYChyoplJzdRjxnkOSV0aUyCruASEDG4TFVnsSZECZXT7VqroFZdceGDRgSBn/nBf16dXdB48AAQBVAgAAAAGqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqgAAAAAA/////wFAnAAAAAAAABl2qRRBfUvpDTU2Mme48q+vyVMREcQa5IisAAAAAAEHa0gwRQIhAL0mcjvP08cl9WJTcf80Sk+jP+OyHJz/mGmWK51deCgzAiAJT3rvOz856UZeEcbcwppdaVWYqJ4xbYuBrvQvofGWcQEhAlMf5gaBNFA9JyMTMifIZ6yPpsg8U36aRMPFvb3LH+M3AAAA',
+    rawTx:
+      '0200000000010205050505050505050505050505050505050505050505050505050505050505050000000000fdffffff1173ae084367aa9ec71ddcd01cae001bdd57a0dd365d0ae076ff82fc08dd0418000000006b483045022100bd26723bcfd3c725f5625371ff344a4fa33fe3b21c9cff9869962b9d5d7828330220094f7aef3b3f39e9465e11c6dcc29a5d695598a89e316d8b81aef42fa1f19671012102531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337fdffffff0250c3000000000000160014670caa79e51d78ed0c583b89ff39d9c49b7199e7487100000000000016001479b000887626b294a914501a4cd226b58b23598302483045022100fd0e4aa059a88760ebc76fae04a298ac9ac2a4d2a0477010330d885d21b58d4e022017f5071ffba16c43a3c07756bc580a1ca8a652737518f19e4392574694c82aee0121031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f0050f80c00',
+    txid: '0bc7db69500768465cd8bd0646217eefc0b91ed62bab603318cf4e58c005e99d'
+  },
+  'unsigned-p2wpkh': {
+    signed:
+      'cHNidP8BAHECAAAAAQYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGAAAAAAD/////AlDDAAAAAAAAFgAUZwyqeeUdeO0MWDuJ/znZxJtxmedIcQAAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDUPgMAAABAR+AOAEAAAAAABYAFHmwAIh2JrKUqRRQGkzSJrWLI1mDAAAA'
+  }
+}
+
+const SPEND_TYPES = ['p2wpkh', 'p2tr', 'p2pkh', 'p2sh-p2wpkh', 'mixed'] as const
+
+describe('finalizePsbt', () => {
+  it.each(SPEND_TYPES)(
+    'finalizes a wallet-signed %s PSBT into the reference raw tx',
+    name => {
+      const fixture = FIXTURES[name]
+      expect(finalizePsbt(base64ToBytes(fixture.signed))).toBe(fixture.rawTx)
+    }
+  )
+
+  // OKX returns every input already finalized, even with autoFinalized: false.
+  it.each(SPEND_TYPES)(
+    'extracts an already-finalized %s PSBT without re-finalizing',
+    name => {
+      const fixture = FIXTURES[name]
+      expect(finalizePsbt(base64ToBytes(fixture.finalized))).toBe(fixture.rawTx)
+    }
+  )
+
+  it.each(SPEND_TYPES)(
+    'computes the reference txid for a %s raw tx',
+    async name => {
+      const fixture = FIXTURES[name]
+      await expect(computeTxid(fixture.rawTx)).resolves.toBe(fixture.txid)
+    }
+  )
+
+  it('rejects an input the wallet did not sign', () => {
+    expect(() =>
+      finalizePsbt(base64ToBytes(FIXTURES['unsigned-p2wpkh'].signed))
+    ).toThrow('input 0 is not signed')
+  })
+
+  it('rejects bytes that are not a PSBT', () => {
+    expect(() => finalizePsbt(Uint8Array.of(1, 2, 3, 4, 5))).toThrow(
+      WalletConnectorError
+    )
+    expect(() => finalizePsbt(Uint8Array.of(1, 2, 3, 4, 5))).toThrow(
+      'not a PSBT'
+    )
+  })
+
+  it('rejects a truncated PSBT instead of extracting a partial tx', () => {
+    const bytes = base64ToBytes(FIXTURES.p2wpkh.signed)
+    expect(() => finalizePsbt(bytes.subarray(0, bytes.length - 10))).toThrow(
+      'truncated data'
+    )
+  })
+
+  it('rejects an empty input', () => {
+    expect(() => finalizePsbt(new Uint8Array())).toThrow(WalletConnectorError)
+  })
+})