@meshconnect/uwc-bridge-parent 1.1.1 → 1.2.0

package/src/BridgeParent.test.ts

@@ -14,7 +14,13 @@ vi.mock('@wallet-standard/app', () => ({
 
 // Mock @solana/wallet-adapter-base
 vi.mock('@solana/wallet-adapter-base', () => ({
-  isWalletAdapterCompatibleStandardWallet: vi.fn().mockReturnValue(false)
+  isWalletAdapterCompatibleStandardWallet: vi.fn().mockReturnValue(false),
+  WalletReadyState: {
+    Installed: 'Installed',
+    NotDetected: 'NotDetected',
+    Loadable: 'Loadable',
+    Unsupported: 'Unsupported'
+  }
 }))
 
 // Mock @solana/wallet-standard-wallet-adapter-base
@@ -29,6 +35,20 @@ vi.mock('@solana/web3.js', () => ({
   VersionedTransaction: { deserialize: vi.fn() }
 }))
 
+// Hoisted mock for BaseWalletAdapter - direct reference avoids restoreAllMocks issues
+const baseAdapterMock = vi.hoisted(() => ({
+  readyState: 'NotDetected' as string,
+  shouldThrow: false,
+  fn: null as ReturnType<typeof vi.fn> | null
+}))
+
+baseAdapterMock.fn = vi.fn()
+
+// Mock ./BaseWalletAdapter
+vi.mock('./BaseWalletAdapter', () => ({
+  BaseWalletAdapter: baseAdapterMock.fn
+}))
+
 describe('BridgeParent', () => {
   let mockIframe: HTMLIFrameElement
 
@@ -394,6 +414,137 @@ describe('BridgeParent', () => {
     })
   })
 
+  describe('Base Wallet detection', () => {
+    beforeEach(async () => {
+      baseAdapterMock.readyState = 'NotDetected'
+      baseAdapterMock.shouldThrow = false
+
+      // Re-set mocks that vi.restoreAllMocks() may have cleared
+      const { getWallets } = await import('@wallet-standard/app')
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [],
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      // Re-set BaseWalletAdapter mock - must use 'function' (not arrow) for 'new' compatibility
+      baseAdapterMock.fn!.mockImplementation(function () {
+        if (baseAdapterMock.shouldThrow) throw new Error('init failed')
+        return {
+          readyState: baseAdapterMock.readyState,
+          name: 'Base Wallet',
+          icon: 'data:image/svg+xml;base64,test',
+          url: 'https://example.com',
+          publicKey: null,
+          connecting: false,
+          connected: false,
+          supportedTransactionVersions: new Set(['legacy', 0]),
+          connect: vi.fn(),
+          disconnect: vi.fn(),
+          sendTransaction: vi.fn(),
+          signTransaction: vi.fn(),
+          signAllTransactions: vi.fn(),
+          signMessage: vi.fn()
+        }
+      })
+    })
+
+    it('should include Base Wallet when detected as Installed', async () => {
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      baseAdapterMock.readyState = 'Installed'
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      const baseWallet = exposedAPI.walletStandardWallets.find(
+        (w: any) => w.name === 'Base Wallet'
+      )
+      expect(baseWallet).toBeDefined()
+      expect(baseWallet.uuid).toBe('base-wallet-traditional')
+      expect(baseWallet.chains).toEqual(['solana:mainnet'])
+      expect(baseWallet.features).toEqual(['traditional-adapter'])
+      expect(baseWallet.adapter).toBeDefined()
+    })
+
+    it('should include Base Wallet when detected as Loadable', async () => {
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      baseAdapterMock.readyState = 'Loadable'
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      const baseWallet = exposedAPI.walletStandardWallets.find(
+        (w: any) => w.name === 'Base Wallet'
+      )
+      expect(baseWallet).toBeDefined()
+    })
+
+    it('should not include Base Wallet when not detected', async () => {
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      const baseWallet = exposedAPI.walletStandardWallets.find(
+        (w: any) => w.name === 'Base Wallet'
+      )
+      expect(baseWallet).toBeUndefined()
+    })
+
+    it('should skip Base Wallet if name already in Wallet Standard wallets', async () => {
+      const { getWallets } = await import('@wallet-standard/app')
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      const existingWallet = {
+        name: 'Base Wallet',
+        chains: ['solana:mainnet'],
+        features: { 'standard:connect': {} },
+        accounts: []
+      }
+
+      vi.mocked(getWallets).mockReturnValue({
+        get: () => [existingWallet] as any,
+        on: vi.fn(),
+        register: vi.fn()
+      } as any)
+
+      baseAdapterMock.readyState = 'Installed'
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      const baseWallets = exposedAPI.walletStandardWallets.filter(
+        (w: any) => w.name === 'Base Wallet'
+      )
+      expect(baseWallets).toHaveLength(1)
+      expect(baseWallets[0].features).not.toContain('traditional-adapter')
+    })
+
+    it('should handle BaseWalletAdapter constructor errors gracefully', async () => {
+      const Comlink = await import('comlink')
+      const { BridgeParent } = await import('./BridgeParent')
+
+      baseAdapterMock.shouldThrow = true
+
+      new BridgeParent(mockIframe)
+      await vi.advanceTimersByTimeAsync(200)
+
+      const exposedAPI = vi.mocked(Comlink.expose).mock.calls[0]?.[0] as any
+      expect(exposedAPI).toBeDefined()
+      expect(exposedAPI.walletStandardWallets).toEqual([])
+    })
+  })
+
   describe('destroy', () => {
     it('should clear all state', async () => {
       const { BridgeParent } = await import('./BridgeParent')

package/src/BridgeParent.ts

@@ -1,9 +1,13 @@
 import * as Comlink from 'comlink'
 import type { Wallet } from '@wallet-standard/base'
 import { getWallets } from '@wallet-standard/app'
-import { isWalletAdapterCompatibleStandardWallet } from '@solana/wallet-adapter-base'
+import {
+  isWalletAdapterCompatibleStandardWallet,
+  WalletReadyState
+} from '@solana/wallet-adapter-base'
 import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js'
 import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-base'
+import { BaseWalletAdapter } from './BaseWalletAdapter'
 
 export interface EthereumProvider {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -375,6 +379,170 @@ export class BridgeParent {
         walletNames.add(wallet.name)
       }
     }
+
+    // Add Base Wallet via traditional adapter (detects window.coinbaseSolana)
+    try {
+      const baseAdapter = new BaseWalletAdapter()
+      const isDetected =
+        baseAdapter.readyState === WalletReadyState.Installed ||
+        baseAdapter.readyState === WalletReadyState.Loadable
+
+      if (isDetected && !walletNames.has(baseAdapter.name)) {
+        solanaWallets.push({
+          uuid: `${baseAdapter.name}-traditional`
+            .toLowerCase()
+            .replace(/\s+/g, '-'),
+          name: baseAdapter.name,
+          chains: ['solana:mainnet'],
+          features: ['traditional-adapter'],
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          adapter: {
+            name: baseAdapter.name,
+            url: baseAdapter.url,
+            // @ts-expect-error icon is string but type expects template literal
+            icon: baseAdapter.icon,
+            readyState: baseAdapter.readyState,
+            // @ts-expect-error publicKey is a Comlink proxy, not a real PublicKey
+            publicKey: Comlink.proxy({
+              get value() {
+                return baseAdapter.publicKey
+              },
+              toBase58: async () => {
+                return baseAdapter.publicKey?.toBase58()
+              },
+              toJSON: async () => {
+                return baseAdapter.publicKey?.toJSON()
+              },
+              toBytes: async () => {
+                return baseAdapter.publicKey?.toBytes()
+              },
+              toBuffer: async () => {
+                return baseAdapter.publicKey?.toBuffer()
+              },
+              toString: async () => {
+                return baseAdapter.publicKey?.toString()
+              }
+            }),
+            connecting: baseAdapter.connecting,
+            connected: baseAdapter.connected,
+            supportedTransactionVersions:
+              baseAdapter.supportedTransactionVersions,
+            connect: async () => await baseAdapter.connect(),
+            disconnect: async () => await baseAdapter.disconnect(),
+            sendTransaction: async (transaction, connection, options) => {
+              try {
+                return await baseAdapter.sendTransaction(
+                  transaction,
+                  connection,
+                  options
+                )
+              } catch {
+                throw new Error('Failed to send transaction')
+              }
+            },
+            signTransaction: async transaction => {
+              return await baseAdapter.signTransaction(transaction)
+            },
+            signAllTransactions: async transactions => {
+              return await baseAdapter.signAllTransactions(transactions)
+            },
+            signMessage: async message => {
+              return await baseAdapter.signMessage(message)
+            },
+            customFunctions: [
+              'sendSerializedTransaction',
+              'signAllSerializedTransactions',
+              'signSerializedTransaction'
+            ],
+            sendSerializedTransaction: async (
+              transaction: ArrayBufferLike,
+              rpcUrl: string
+            ) => {
+              const connection = new Connection(rpcUrl)
+              const uint8Array = new Uint8Array(transaction)
+
+              let deserializedTx: Transaction | VersionedTransaction
+              try {
+                deserializedTx = VersionedTransaction.deserialize(uint8Array)
+              } catch {
+                try {
+                  deserializedTx = Transaction.from(uint8Array)
+                } catch {
+                  throw new Error(
+                    'Failed to deserialize transaction as either versioned or legacy format'
+                  )
+                }
+              }
+              try {
+                const txHash = await baseAdapter.sendTransaction(
+                  deserializedTx,
+                  connection
+                )
+                return txHash
+              } catch {
+                throw new Error('Failed to send serialized transaction')
+              }
+            },
+            // @ts-expect-error return type includes VersionedTransaction
+            signSerializedTransaction: async (transaction: ArrayBufferLike) => {
+              const uint8Array = new Uint8Array(transaction)
+
+              let deserializedTx: Transaction | VersionedTransaction
+              try {
+                deserializedTx = VersionedTransaction.deserialize(uint8Array)
+              } catch {
+                try {
+                  deserializedTx = Transaction.from(uint8Array)
+                } catch {
+                  throw new Error(
+                    'Failed to deserialize transaction as either versioned or legacy format'
+                  )
+                }
+              }
+
+              return await baseAdapter.signTransaction(deserializedTx)
+            },
+            // @ts-expect-error return type includes VersionedTransaction
+            signAllSerializedTransactions: async (
+              transactions: ArrayBufferLike[]
+            ) => {
+              const deserializedTransactions: (
+                | Transaction
+                | VersionedTransaction
+              )[] = []
+
+              for (const transaction of transactions) {
+                const uint8Array = new Uint8Array(transaction)
+
+                let deserializedTx: Transaction | VersionedTransaction
+                try {
+                  deserializedTx = VersionedTransaction.deserialize(uint8Array)
+                } catch {
+                  try {
+                    deserializedTx = Transaction.from(uint8Array)
+                  } catch {
+                    throw new Error(
+                      'Failed to deserialize one or more transactions'
+                    )
+                  }
+                }
+
+                deserializedTransactions.push(deserializedTx)
+              }
+
+              return await baseAdapter.signAllTransactions(
+                deserializedTransactions
+              )
+            }
+          }
+        })
+        walletNames.add(baseAdapter.name)
+      }
+    } catch {
+      // Silently handle if Base Wallet adapter fails to initialize
+    }
+
     return solanaWallets
   }