@meshconnect/uwc-bridge-parent 1.5.0 → 1.6.0

package/src/BridgeParent.test.ts

@@ -276,8 +276,10 @@ describe('BridgeParent', () => {
       await vi.advanceTimersByTimeAsync(400)
 
       const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
-      // Solana readiness is true right after init — a real precondition, not a setup.
+      // Solana/Bitcoin readiness is true right after init — a real
+      // precondition, not a setup.
       expect(exposedAPI.walletStandardWalletsReady).toBe(true)
+      expect(exposedAPI.bip122WalletsReady).toBe(true)
       exposedAPI.tronWalletsReady = true
       exposedAPI.tonWalletsReady = true
       exposedAPI.eip6963WalletsReady = true
@@ -288,6 +290,37 @@ describe('BridgeParent', () => {
       expect(exposedAPI.tonWalletsReady).toBe(false)
       expect(exposedAPI.eip6963WalletsReady).toBe(false)
       expect(exposedAPI.walletStandardWalletsReady).toBe(false)
+      expect(exposedAPI.bip122WalletsReady).toBe(false)
+    })
+
+    it('resets bip122Wallets to an empty array on destroy', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () =>
+          [
+            {
+              name: 'MetaMask',
+              chains: ['bitcoin:mainnet'],
+              features: { 'bitcoin:connect': { connect: vi.fn() } },
+              accounts: []
+            }
+          ] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      const bridge = new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      expect(exposedAPI.bip122Wallets).toHaveLength(1)
+
+      bridge.destroy()
+
+      expect(exposedAPI.bip122Wallets).toEqual([])
     })
 
     it('is a safe no-op when the iframe never had a contentWindow', async () => {
@@ -443,6 +476,287 @@ describe('BridgeParent', () => {
     })
   })
 
+  describe('Bitcoin wallet discovery', () => {
+    it('should call getWallets and filter bitcoin:* wallets', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      const mockBitcoinWallet = {
+        name: 'MetaMask',
+        chains: ['bitcoin:mainnet'],
+        features: {
+          'bitcoin:connect': { connect: vi.fn() },
+          'bitcoin:signMessage': { signMessage: vi.fn() },
+          'bitcoin:signTransaction': { signTransaction: vi.fn() }
+        },
+        accounts: []
+      }
+      const mockNonBitcoinWallet = {
+        name: 'SomeWallet',
+        chains: ['ethereum:1'],
+        features: {},
+        accounts: []
+      }
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [mockBitcoinWallet, mockNonBitcoinWallet] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      expect(exposedAPI.bip122Wallets).toHaveLength(1)
+      expect(exposedAPI.bip122Wallets[0].name).toBe('MetaMask')
+      expect(exposedAPI.bip122Wallets[0].features).toEqual([
+        'bitcoin:connect',
+        'bitcoin:signMessage',
+        'bitcoin:signTransaction'
+      ])
+      expect(exposedAPI.bip122Wallets[0].wallet.accounts).toEqual([])
+      expect(
+        exposedAPI.bip122Wallets[0].wallet.features['bitcoin:connect']
+      ).toBeDefined()
+      expect(exposedAPI.bip122WalletsReady).toBe(true)
+    })
+
+    it('keys the uuid on the bitcoin: chain, not chains[0], for a multi-chain wallet', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      // MetaMask-shaped: eip155 chains registered first, bitcoin: chain last.
+      const mockMultiChainWallet = {
+        name: 'MetaMask',
+        chains: ['eip155:1', 'eip155:137', 'bitcoin:mainnet'],
+        features: {
+          'bitcoin:connect': { connect: vi.fn() },
+          'bitcoin:signMessage': { signMessage: vi.fn() },
+          'bitcoin:signTransaction': { signTransaction: vi.fn() }
+        },
+        accounts: []
+      }
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [mockMultiChainWallet] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      expect(exposedAPI.bip122Wallets).toHaveLength(1)
+      // Must key on 'bitcoin:mainnet' (bitcoinChain), not 'eip155:1'
+      // (chains[0]) — otherwise this uuid disagrees with the local
+      // (unframed) discovery path's uuid for the exact same wallet.
+      expect(exposedAPI.bip122Wallets[0].uuid).toBe('metamask-bitcoin:mainnet')
+    })
+
+    it('should return empty array when no bitcoin wallets found', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [],
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      expect(exposedAPI.bip122Wallets).toEqual([])
+    })
+
+    it('omits a feature entry the wallet does not declare', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      const mockWallet = {
+        name: 'PartialWallet',
+        chains: ['bitcoin:mainnet'],
+        features: { 'bitcoin:connect': { connect: vi.fn() } },
+        accounts: []
+      }
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [mockWallet] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      const wallet = exposedAPI.bip122Wallets[0].wallet
+      expect(wallet.features['bitcoin:connect']).toBeDefined()
+      expect(wallet.features['bitcoin:signMessage']).toBeUndefined()
+      expect(wallet.features['bitcoin:signTransaction']).toBeUndefined()
+    })
+  })
+
+  describe('subscribeBip122WalletEvent', () => {
+    // Bitcoin has no adapter class to construct (unlike Solana's
+    // StandardWalletAdapter) — `getBitcoinWallets()` reshapes the raw
+    // registry wallet directly, so the resolver just re-scans the registry
+    // for a `bitcoin:*` wallet whose uuid matches. `standard:events` is the
+    // ONLY path (no connect/disconnect fallback), since there is no adapter
+    // to re-emit them.
+    async function armStandardEventsBitcoinWallet(
+      initialAccounts: { address: string }[],
+      chains: string[] = ['bitcoin:mainnet']
+    ) {
+      const { getWallets } = await import('@wallet-standard/app')
+
+      let changeListener: ((props: unknown) => void) | undefined
+      const off = vi.fn()
+      const wallet = {
+        name: 'MetaMask',
+        chains,
+        accounts: initialAccounts,
+        features: {
+          'bitcoin:connect': { connect: vi.fn() },
+          'standard:events': {
+            on: vi.fn((event: string, listener: (props: unknown) => void) => {
+              if (event === 'change') changeListener = listener
+              return off
+            })
+          }
+        }
+      }
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [wallet] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      const { BridgeParent } = await import('./BridgeParent')
+      const bridgeParent = new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(400)
+
+      const callback = vi.fn()
+      const walletId = `metamask-${chains.find(c => c.startsWith('bitcoin:')) ?? chains[0]}`
+      const teardown = (
+        bridgeParent as any
+      ).parentAPI.subscribeBip122WalletEvent(walletId, callback)
+
+      return {
+        wallet,
+        off,
+        callback,
+        teardown,
+        fire: (props: unknown) => changeListener?.(props)
+      }
+    }
+
+    it('throws when no wallet matches the given walletId', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [],
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+      const { BridgeParent } = await import('./BridgeParent')
+      const bridgeParent = new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(400)
+
+      expect(() =>
+        (bridgeParent as any).parentAPI.subscribeBip122WalletEvent(
+          'unknown-wallet-id',
+          vi.fn()
+        )
+      ).toThrow(/no wallet found for walletId/)
+    })
+
+    it('returns undefined when the resolved wallet exposes no standard:events', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      vi.mocked(getWallets).mockReturnValue({
+        get: () =>
+          [
+            {
+              name: 'MetaMask',
+              chains: ['bitcoin:mainnet'],
+              accounts: [],
+              features: { 'bitcoin:connect': { connect: vi.fn() } }
+            }
+          ] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+      const { BridgeParent } = await import('./BridgeParent')
+      const bridgeParent = new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(400)
+
+      const teardown = (
+        bridgeParent as any
+      ).parentAPI.subscribeBip122WalletEvent(
+        'metamask-bitcoin:mainnet',
+        vi.fn()
+      )
+      expect(teardown).toBeUndefined()
+    })
+
+    it('resolves a multi-chain wallet (eip155 first) by its bitcoin:-keyed walletId, not chains[0]', async () => {
+      const { teardown } = await armStandardEventsBitcoinWallet(
+        [{ address: 'bc1qexisting' }],
+        ['eip155:1', 'eip155:137', 'bitcoin:mainnet']
+      )
+      expect(typeof teardown).toBe('function')
+    })
+
+    it('subscribes to standard:events change and forwards the active address as a plain string', async () => {
+      const { wallet, teardown, off } = await armStandardEventsBitcoinWallet([
+        { address: 'bc1qoriginal' }
+      ])
+
+      expect(wallet.features['standard:events'].on).toHaveBeenCalledWith(
+        'change',
+        expect.any(Function)
+      )
+      expect(typeof teardown).toBe('function')
+      expect(Comlink.proxy).toHaveBeenCalledWith(expect.any(Function))
+      expect(off).not.toHaveBeenCalled()
+    })
+
+    it('propagates a switch, then null on de-auth, and ignores non-account changes', async () => {
+      const { wallet, callback, off, teardown, fire } =
+        await armStandardEventsBitcoinWallet([{ address: 'bc1qACC1' }])
+
+      wallet.accounts = [{ address: 'bc1qACC2' }]
+      fire({ accounts: wallet.accounts })
+      expect(callback).toHaveBeenNthCalledWith(1, 'bc1qACC2')
+
+      // A pure chain/feature change (no `accounts` key) must be ignored.
+      fire({ chains: ['bitcoin:mainnet'] })
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      wallet.accounts = []
+      fire({ accounts: [] })
+      expect(callback).toHaveBeenNthCalledWith(2, null)
+
+      teardown?.()
+      expect(off).toHaveBeenCalledTimes(1)
+    })
+
+    it('never lets the wallet-standard unsubscribe return value escape the teardown (unserializable-return-value guard)', async () => {
+      const { off, teardown } = await armStandardEventsBitcoinWallet([
+        { address: 'bc1qACC1' }
+      ])
+      off.mockReturnValue({ some: 'non-cloneable-emitter-return' })
+      expect(() => teardown?.()).not.toThrow()
+    })
+  })
+
   describe('Tron wallet discovery', () => {
     it('should start with empty tron wallets and not ready', async () => {
       const Comlink = await import('comlink')

package/src/BridgeParent.ts

@@ -100,6 +100,44 @@ export interface WalletStandardInfo {
   adapter: ExtendedStandardWalletAdapter | undefined
 }
 
+interface Bip122ConnectFeature {
+  connect: (input: unknown) => Promise<unknown>
+}
+
+interface Bip122SignMessageFeature {
+  signMessage: (input: unknown) => Promise<unknown>
+}
+
+interface Bip122SignTransactionFeature {
+  signTransaction: (input: unknown) => Promise<unknown>
+}
+
+/**
+ * Wallet Standard `bitcoin:*` wallet, reshaped into plain data (`name`,
+ * `accounts`) plus Comlink-proxied feature methods so it survives the
+ * postMessage bridge — mirrors `WalletStandardBitcoinWallet`
+ * (`@meshconnect/uwc-bitcoin`), duck-typed here rather than imported to avoid
+ * a new cross-package dependency (same approach as the Tron/TON provider
+ * shapes below).
+ */
+export interface Bip122WireWallet {
+  name: string
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  accounts: any[]
+  features: {
+    'bitcoin:connect'?: Bip122ConnectFeature | undefined
+    'bitcoin:signMessage'?: Bip122SignMessageFeature | undefined
+    'bitcoin:signTransaction'?: Bip122SignTransactionFeature | undefined
+  }
+}
+
+export interface Bip122WalletInfo {
+  uuid: string
+  name: string
+  features: string[]
+  wallet: Bip122WireWallet
+}
+
 export interface EIP6963ProviderInfo {
   uuid: string
   name: string
@@ -149,6 +187,9 @@ export interface ParentAPI {
   walletStandardWallets: WalletStandardInfo[]
   walletStandardWalletsReady: boolean
 
+  bip122Wallets: Bip122WalletInfo[]
+  bip122WalletsReady: boolean
+
   tronWallets: TronWalletInfo[]
   tronWalletsReady: boolean
 
@@ -210,6 +251,24 @@ export interface ParentAPI {
     walletId: string,
     callback: (address: string | null) => void
   ) => (() => void) | undefined
+
+  /**
+   * Bitcoin peer of `subscribeSolanaWalletEvent`. `walletId` is the SAME id
+   * `bip122Wallets[].uuid` publishes (see `generateBip122WalletId`), which the
+   * child mirrors back as `BitcoinWalletService.connectedWalletUuid`. Bitcoin
+   * has no adapter class re-emitting `connect`/`disconnect` on a switch (the
+   * way `StandardWalletAdapter` does for Solana) — `standard:events` is the
+   * ONLY path, not a preferred one with a fallback. Forwards a plain
+   * `string | null` (never the raw account object) to `callback`, a
+   * Comlink-proxied callback the child supplies. Throws when no wallet
+   * matches `walletId` (reported as a bridge error on the child side,
+   * mirroring `subscribeSolanaWalletEvent`'s walletId-miss); returns
+   * `undefined` when the resolved wallet exposes no `standard:events`.
+   */
+  subscribeBip122WalletEvent: (
+    walletId: string,
+    callback: (address: string | null) => void
+  ) => (() => void) | undefined
 }
 
 export class BridgeParent {
@@ -252,14 +311,18 @@ export class BridgeParent {
     // flags gate the child from reading a still-empty array.
     const eip6963Promise = this.discovereip6963Wallets()
     this.eip6963DiscoveryPromise = eip6963Promise
-    // Solana is synchronous, so run it inline (no benefit to a microtask hop)
+    // Solana and Bitcoin are both synchronous Wallet Standard registry reads,
+    // so run them inline (no benefit to a microtask hop).
     const walletStandardWallets = this.getSolanaWallets()
+    const bip122Wallets = this.getBitcoinWallets()
 
     this.parentAPI = {
       eip6963Wallets: [],
       eip6963WalletsReady: false,
       walletStandardWallets: walletStandardWallets,
       walletStandardWalletsReady: true,
+      bip122Wallets: bip122Wallets,
+      bip122WalletsReady: true,
       tronWallets: [],
       tronWalletsReady: false,
 
@@ -491,6 +554,49 @@ export class BridgeParent {
           adapter.off('connect', onConnect)
           adapter.off('disconnect', onDisconnect)
         })
+      },
+      subscribeBip122WalletEvent: (
+        walletId: string,
+        callback: (address: string | null) => void
+      ): (() => void) | undefined => {
+        const wallet = this.resolveBip122WalletForEvent(walletId)
+        if (!wallet) {
+          // Same rationale as subscribeSolanaWalletEvent's walletId miss —
+          // surface a genuine "nothing at this walletId" miss as a reported
+          // bridge error instead of a silent no-op.
+          throw new Error(
+            `subscribeBip122WalletEvent: no wallet found for walletId "${walletId}"`
+          )
+        }
+        // ONLY path — Bitcoin has no adapter class to re-emit connect/disconnect
+        // on a switch the way StandardWalletAdapter does for Solana, so there is
+        // no fallback branch here: standard:events is the sole account-change
+        // signal a bitcoin:* wallet exposes.
+        const standardWallet = wallet as unknown as StandardEventsCapableWallet
+        const standardEvents = standardWallet.features?.['standard:events']
+        if (typeof standardEvents?.on !== 'function') return undefined
+
+        // Reduce to a plain string | null BEFORE crossing Comlink — the raw
+        // account object isn't structured-cloneable and the child only needs
+        // the address. null = the switch de-authorized the dapp → the child
+        // maps it to [] (disconnect), a non-null address maps to [address].
+        const forwardActiveAccount = () => {
+          callback(standardWallet.accounts?.[0]?.address ?? null)
+        }
+        const off = standardEvents.on('change', properties => {
+          // React only to account-set changes; ignore pure chain/feature deltas.
+          if (properties && 'accounts' in properties) forwardActiveAccount()
+        })
+        // Block body (not an expression arrow): the wallet-standard unsubscribe
+        // returns its own value, which must not become this teardown's
+        // (unserializable) return across Comlink. Best-effort + idempotent.
+        return Comlink.proxy(() => {
+          try {
+            off?.()
+          } catch {
+            // Unsubscribe must never throw across the bridge.
+          }
+        })
       }
     }
 
@@ -1018,11 +1124,113 @@ export class BridgeParent {
     return hasSolanaChain
   }
 
+  private isBitcoinWallet(wallet: Wallet): boolean {
+    const chains = wallet.chains || []
+    return chains.some(chain => chain.startsWith('bitcoin:'))
+  }
+
+  /**
+   * Wallet Standard `bitcoin:*` discovery — the Bitcoin peer of
+   * `getSolanaWallets`. Reshapes each matching registry wallet into plain
+   * data (`accounts`) plus individually Comlink-proxied feature methods
+   * (`bitcoin:connect`/`signMessage`/`signTransaction`), each left `undefined`
+   * when the real wallet doesn't declare it — so `WalletStandardBitcoinAdapter`'s
+   * own presence checks (`if (!feature) throw ...`) still work once marshaled
+   * across the bridge.
+   */
+  private getBitcoinWallets(): Bip122WalletInfo[] {
+    const { get } = getWallets()
+    const wallets = get()
+
+    const bitcoinWallets: Bip122WalletInfo[] = []
+
+    for (const wallet of wallets) {
+      if (!this.isBitcoinWallet(wallet)) continue
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const features = wallet.features as Record<string, any>
+      const connectFeature = features['bitcoin:connect']
+      const signMessageFeature = features['bitcoin:signMessage']
+      const signTransactionFeature = features['bitcoin:signTransaction']
+
+      bitcoinWallets.push({
+        uuid: this.generateBip122WalletId(wallet),
+        name: wallet.name,
+        features: Object.keys(wallet.features),
+        wallet: {
+          name: wallet.name,
+          accounts: wallet.accounts as unknown[],
+          features: {
+            'bitcoin:connect': connectFeature
+              ? Comlink.proxy({
+                  connect: async (input: unknown) =>
+                    await connectFeature.connect(input)
+                })
+              : undefined,
+            'bitcoin:signMessage': signMessageFeature
+              ? Comlink.proxy({
+                  signMessage: async (input: unknown) =>
+                    await signMessageFeature.signMessage(input)
+                })
+              : undefined,
+            'bitcoin:signTransaction': signTransactionFeature
+              ? Comlink.proxy({
+                  signTransaction: async (input: unknown) =>
+                    await signTransactionFeature.signTransaction(input)
+                })
+              : undefined
+          }
+        }
+      })
+    }
+
+    return bitcoinWallets
+  }
+
   private generateWalletId(wallet: Wallet): string {
     const chain = wallet.chains?.[0] || 'unknown'
     return `${wallet.name}-${chain}`.toLowerCase().replace(/\s+/g, '-')
   }
 
+  /**
+   * Bitcoin peer of `generateWalletId`, kept separate rather than shared: it
+   * keys on the wallet's first `bitcoin:` chain, not `chains[0]` — MetaMask's
+   * bitcoin:* wallet is multi-chain (eip155 chains registered first), so
+   * `chains[0]` would key this id off an unrelated namespace. Mirrors the
+   * same fix already applied to the local (unframed) discovery path in
+   * wallet-standard-discovery.ts. Used by both `getBitcoinWallets()` and
+   * `resolveBip122WalletForEvent()` so they agree on the same id.
+   */
+  private generateBip122WalletId(wallet: Wallet): string {
+    const bitcoinChain =
+      wallet.chains?.find(chain => chain.startsWith('bitcoin:')) ||
+      wallet.chains?.[0] ||
+      'unknown'
+    return `${wallet.name}-${bitcoinChain}`.toLowerCase().replace(/\s+/g, '-')
+  }
+
+  /**
+   * Resolve the REAL registry wallet for `walletId` (the same id
+   * `getBitcoinWallets()` publishes as `Bip122WalletInfo.uuid`) so
+   * `subscribeBip122WalletEvent` can attach a live listener. Unlike Solana,
+   * Bitcoin has no adapter class to construct — `getBitcoinWallets()` already
+   * reshapes the raw registry `Wallet` directly, so this returns that same
+   * raw `Wallet`, which still carries `standard:events` (the reshaped
+   * `Bip122WireWallet` sent across the bridge does not).
+   */
+  private resolveBip122WalletForEvent(walletId: string): Wallet | undefined {
+    const { get } = getWallets()
+    const wallets = get()
+
+    for (const wallet of wallets) {
+      if (!this.isBitcoinWallet(wallet)) continue
+      if (this.generateBip122WalletId(wallet) !== walletId) continue
+      return wallet
+    }
+
+    return undefined
+  }
+
   /**
    * Checks if a value looks like a Tron provider (has request and tronWeb)
    */
@@ -1351,10 +1559,12 @@ export class BridgeParent {
     if (this.parentAPI) {
       this.parentAPI.eip6963WalletsReady = false
       this.parentAPI.walletStandardWalletsReady = false
+      this.parentAPI.bip122WalletsReady = false
       this.parentAPI.tronWalletsReady = false
       this.parentAPI.tonWalletsReady = false
       this.parentAPI.eip6963Wallets = []
       this.parentAPI.walletStandardWallets = []
+      this.parentAPI.bip122Wallets = []
       this.parentAPI.tronWallets = []
       this.parentAPI.tonWallets = []
       this.parentAPI = null