@meshconnect/uwc-bitcoin 0.2.2 → 0.2.4-snapshot.aa56682

package/src/bitcoin-namespace.test.ts

@@ -1,11 +1,17 @@
-import { describe, it, expect } from 'vitest'
-import type { Network } from '@meshconnect/uwc-types'
+import { describe, it, expect, vi } from 'vitest'
+import type {
+  BitcoinAccount,
+  BitcoinSignMessageParams,
+  Network,
+  SignatureType
+} from '@meshconnect/uwc-types'
 import { WalletConnectorError } from '@meshconnect/uwc-types'
 import {
   BitcoinNamespace,
   assertBitcoinNetwork,
   BITCOIN_NAMESPACE
 } from './bitcoin-namespace'
+import type { BitcoinTransportAdapter } from './adapter'
 
 const bitcoinNetwork: Network = {
   internalId: 0,
@@ -27,6 +33,23 @@ const ethereumNetwork: Network = {
   networkType: 'evm'
 }
 
+const account: BitcoinAccount = {
+  address: 'bc1qexampleaddress',
+  publicKey: '02aabbcc',
+  purpose: 'payment'
+}
+
+const signature: SignatureType = { type: 'standard', signature: 'deadbeef' }
+
+/** Full fake adapter so the namespace's delegation can be asserted. */
+const fakeAdapter = (): BitcoinTransportAdapter => ({
+  getAccounts: vi.fn().mockResolvedValue([account]),
+  signMessage: vi.fn().mockResolvedValue(signature),
+  signPsbt: vi.fn().mockResolvedValue('c2lnbmVk'),
+  sendTransfer: vi.fn().mockResolvedValue('txid-abc'),
+  disconnect: vi.fn().mockResolvedValue(undefined)
+})
+
 describe('assertBitcoinNetwork', () => {
   it('passes for a bip122 network', () => {
     expect(() => assertBitcoinNetwork(bitcoinNetwork, 'test')).not.toThrow()
@@ -48,18 +71,81 @@ describe('assertBitcoinNetwork', () => {
 describe('BitcoinNamespace', () => {
   it('serves the bip122 namespace', () => {
     expect(BITCOIN_NAMESPACE).toBe('bip122')
-    expect(new BitcoinNamespace().namespace).toBe(BITCOIN_NAMESPACE)
+    expect(new BitcoinNamespace(fakeAdapter()).namespace).toBe(
+      BITCOIN_NAMESPACE
+    )
   })
 
   it('assertSupportedNetwork accepts a bip122 network', () => {
     expect(() =>
-      new BitcoinNamespace().assertSupportedNetwork(bitcoinNetwork)
+      new BitcoinNamespace(fakeAdapter()).assertSupportedNetwork(bitcoinNetwork)
     ).not.toThrow()
   })
 
   it('assertSupportedNetwork rejects a non-bip122 network', () => {
     expect(() =>
-      new BitcoinNamespace().assertSupportedNetwork(ethereumNetwork)
+      new BitcoinNamespace(fakeAdapter()).assertSupportedNetwork(
+        ethereumNetwork
+      )
     ).toThrow(WalletConnectorError)
   })
+
+  it('delegates getAccounts to the adapter', async () => {
+    const adapter = fakeAdapter()
+    const result = await new BitcoinNamespace(adapter).getAccounts()
+    expect(adapter.getAccounts).toHaveBeenCalledOnce()
+    expect(result).toEqual([account])
+  })
+
+  it('delegates signMessage to the adapter with the same params', async () => {
+    const adapter = fakeAdapter()
+    const params: BitcoinSignMessageParams = { account, message: 'verify me' }
+    const result = await new BitcoinNamespace(adapter).signMessage(params)
+    expect(adapter.signMessage).toHaveBeenCalledWith(params)
+    expect(result).toBe(signature)
+  })
+
+  it('delegates disconnect and tolerates an adapter without one', async () => {
+    const adapter = fakeAdapter()
+    await new BitcoinNamespace(adapter).disconnect()
+    expect(adapter.disconnect).toHaveBeenCalledOnce()
+
+    const noDisconnect: BitcoinTransportAdapter = {
+      getAccounts: adapter.getAccounts,
+      signMessage: adapter.signMessage
+    }
+    await expect(
+      new BitcoinNamespace(noDisconnect).disconnect()
+    ).resolves.toBeUndefined()
+  })
+
+  it('delegates signPsbt to the adapter', async () => {
+    const adapter = fakeAdapter()
+    const request = { from: 'bc1qexampleaddress', psbt: 'cHNidA==' }
+    const result = await new BitcoinNamespace(adapter).signPsbt(request)
+    expect(adapter.signPsbt).toHaveBeenCalledWith(request)
+    expect(result).toBe('c2lnbmVk')
+  })
+
+  it('delegates sendTransfer to the adapter', async () => {
+    const adapter = fakeAdapter()
+    const request = { from: 'bc1qexampleaddress', to: 'bc1qdest', amount: 1000 }
+    const result = await new BitcoinNamespace(adapter).sendTransfer(request)
+    expect(adapter.sendTransfer).toHaveBeenCalledWith(request)
+    expect(result).toBe('txid-abc')
+  })
+
+  it('rejects when the adapter does not support signPsbt / sendTransfer', async () => {
+    const signOnly: BitcoinTransportAdapter = {
+      getAccounts: vi.fn(),
+      signMessage: vi.fn()
+    }
+    const ns = new BitcoinNamespace(signOnly)
+    await expect(
+      ns.signPsbt({ from: 'bc1q', psbt: 'x' })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+    await expect(
+      ns.sendTransfer({ from: 'bc1q', to: 'bc1q2', amount: 1 })
+    ).rejects.toBeInstanceOf(WalletConnectorError)
+  })
 })

package/src/bitcoin-namespace.ts

@@ -1,5 +1,15 @@
-import type { Namespace, Network } from '@meshconnect/uwc-types'
+import type {
+  BitcoinAccount,
+  BitcoinPsbtSignRequest,
+  BitcoinSendTransferRequest,
+  BitcoinSignMessageParams,
+  Namespace,
+  Network,
+  SignatureType,
+  TransactionResult
+} from '@meshconnect/uwc-types'
 import { WalletConnectorError } from '@meshconnect/uwc-types'
+import type { BitcoinTransportAdapter } from './adapter'
 
 /** CAIP-2 namespace this module serves. */
 export const BITCOIN_NAMESPACE: Namespace = 'bip122'
@@ -25,15 +35,14 @@ export function assertBitcoinNetwork(network: Network, method: string): void {
  * (`injected-connector`, `wallet-connect-connector`) own wallet discovery,
  * pairing, and the provider/session lifecycle. This module owns only
  * Bitcoin-specific operations performed against a transport-supplied
- * provider/session — enumerating bip122 accounts, signing messages,
- * building/signing/finalizing PSBTs, and broadcasting. Both transports
- * dispatch their `bip122` branch into the matching adapter here.
+ * provider/session, delegating each to the {@link BitcoinTransportAdapter} it
+ * was constructed with — the transport builds that adapter bound to the live
+ * session.
  *
- * Those operations, and the provider/session types they take, land on the
- * `BitcoinTransportAdapter` port in Phase 2 — deferred here so the scaffold
- * doesn't pre-commit signatures before those types exist.
- *
- * Phase 1 (scaffold): namespace identity + the shared network guard only.
+ * 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.
  *
  * Phased build plan:
  * https://app.notion.com/p/3a5f862e950a8187b3d3f0e255d13f45
@@ -42,8 +51,53 @@ export class BitcoinNamespace {
   /** CAIP-2 namespace this module serves. */
   readonly namespace = BITCOIN_NAMESPACE
 
+  constructor(private readonly adapter: BitcoinTransportAdapter) {}
+
   /** Throws unless `network` is a bip122 network. */
   assertSupportedNetwork(network: Network): void {
     assertBitcoinNetwork(network, 'BitcoinNamespace.assertSupportedNetwork')
   }
+
+  /** Enumerate the bip122 accounts on the connected session. */
+  getAccounts(): Promise<BitcoinAccount[]> {
+    return this.adapter.getAccounts()
+  }
+
+  /** Sign a message with the given account. */
+  signMessage(params: BitcoinSignMessageParams): Promise<SignatureType> {
+    return this.adapter.signMessage(params)
+  }
+
+  /**
+   * Sign a PSBT (Path B). Returns the wallet-signed PSBT (base64); finalizing +
+   * broadcasting is a separate step. Rejects if the active adapter's wallet
+   * does not support PSBT signing.
+   */
+  async signPsbt(request: BitcoinPsbtSignRequest): Promise<string> {
+    if (!this.adapter.signPsbt) throw this.unsupported('signPsbt')
+    return this.adapter.signPsbt(request)
+  }
+
+  /**
+   * High-level transfer (Path A): the wallet signs and broadcasts, returning a
+   * txid. Rejects if the active adapter's transport does not offer it.
+   */
+  async sendTransfer(
+    request: BitcoinSendTransferRequest
+  ): Promise<TransactionResult> {
+    if (!this.adapter.sendTransfer) throw this.unsupported('sendTransfer')
+    return this.adapter.sendTransfer(request)
+  }
+
+  /** Release any session resources the adapter holds. */
+  async disconnect(): Promise<void> {
+    await this.adapter.disconnect?.()
+  }
+
+  private unsupported(method: string): WalletConnectorError {
+    return new WalletConnectorError({
+      type: 'unknown',
+      message: `BitcoinNamespace.${method}: the active adapter does not support it`
+    })
+  }
 }

package/src/encoding.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal encoding helpers for the boundary between our transport-agnostic
+ * domain shapes (hex/base64 strings, JSON-safe) and the Wallet Standard
+ * `bitcoin:*` interface (raw `Uint8Array`). Uses only Web-standard APIs
+ * (`TextEncoder`, `atob`/`btoa`) so `uwc-bitcoin` stays dependency-free.
+ */
+
+export function utf8ToBytes(text: string): Uint8Array {
+  return new TextEncoder().encode(text)
+}
+
+export function bytesToHex(bytes: Uint8Array): string {
+  let hex = ''
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, '0')
+  return hex
+}
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  let binary = ''
+  for (const byte of bytes) binary += String.fromCharCode(byte)
+  return btoa(binary)
+}
+
+export function base64ToBytes(base64: string): Uint8Array {
+  const binary = atob(base64)
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+  return bytes
+}

package/src/index.ts

@@ -3,3 +3,11 @@ export {
   assertBitcoinNetwork,
   BITCOIN_NAMESPACE
 } from './bitcoin-namespace'
+export type { BitcoinTransportAdapter } from './adapter'
+export { WalletStandardBitcoinAdapter } from './adapters/wallet-standard'
+export type {
+  WalletStandardBitcoinWallet,
+  WalletStandardBitcoinAccount
+} from './adapters/wallet-standard'
+export { WalletConnectBitcoinAdapter } from './adapters/walletconnect'
+export type { BitcoinWalletConnectRequest } from './adapters/walletconnect'