@meshconnect/uwc-bridge-parent 1.1.1 → 1.2.1

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
@@ -73,6 +77,15 @@ export interface TronWalletInfo {
   provider: any
 }
 
+export interface TonWalletInfo {
+  uuid: string
+  name: string
+  icon: string
+  jsBridgeKey: string
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  provider: any
+}
+
 export interface ParentAPI {
   eip6963Wallets: DetectedWallet[]
   eip6963WalletsReady: boolean
@@ -83,7 +96,11 @@ export interface ParentAPI {
   tronWallets: TronWalletInfo[]
   tronWalletsReady: boolean
 
+  tonWallets: TonWalletInfo[]
+  tonWalletsReady: boolean
+
   discoverTronWallets: (injectedIds: string[]) => void
+  discoverTonWallets: (jsBridgeKeys: string[]) => void
 }
 
 export class BridgeParent {
@@ -118,12 +135,23 @@ export class BridgeParent {
       tronWallets: [],
       tronWalletsReady: false,
 
+      tonWallets: [],
+      tonWalletsReady: false,
+
       // Called by BridgeChild to trigger Tron wallet discovery with injectedIds
       discoverTronWallets: (injectedIds: string[]) => {
         if (this.parentAPI) {
           this.parentAPI.tronWallets = this.getTronWallets(injectedIds)
           this.parentAPI.tronWalletsReady = true
         }
+      },
+
+      // Called by BridgeChild to trigger TON wallet discovery with jsBridgeKeys
+      discoverTonWallets: (jsBridgeKeys: string[]) => {
+        if (this.parentAPI) {
+          this.parentAPI.tonWallets = this.getTonWallets(jsBridgeKeys)
+          this.parentAPI.tonWalletsReady = true
+        }
       }
     }
 
@@ -375,6 +403,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
   }
 
@@ -485,11 +677,67 @@ export class BridgeParent {
     return wallets
   }
 
+  private isTonConnectBridge(value: unknown): boolean {
+    if (!value || typeof value !== 'object') return false
+    const bridge = value as Record<string, unknown>
+    return (
+      typeof bridge['connect'] === 'function' &&
+      typeof bridge['send'] === 'function' &&
+      typeof bridge['listen'] === 'function'
+    )
+  }
+
+  private getTonWallets(jsBridgeKeys: string[]): TonWalletInfo[] {
+    if (typeof window === 'undefined' || jsBridgeKeys.length === 0) {
+      return []
+    }
+
+    const wallets: TonWalletInfo[] = []
+    const seen = new Set<string>()
+
+    for (const key of jsBridgeKeys) {
+      if (seen.has(key)) continue
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const root = (window as any)[key]
+      if (!root || typeof root !== 'object') continue
+
+      const bridge = root['tonconnect']
+      if (!this.isTonConnectBridge(bridge)) continue
+
+      seen.add(key)
+
+      // Explicitly whitelist bridge methods to bound cross-origin surface
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const actualBridge = bridge as any
+      wallets.push({
+        uuid: `ton-${key}`.toLowerCase(),
+        name: actualBridge.deviceInfo?.appName || key,
+        icon: '',
+        jsBridgeKey: key,
+        provider: Comlink.proxy({
+          deviceInfo: actualBridge.deviceInfo,
+          connect: async (protocolVersion: number, message: string) =>
+            await actualBridge.connect(protocolVersion, message),
+          send: async (message: string) => await actualBridge.send(message),
+          listen: (callback: (event: string) => void) =>
+            actualBridge.listen(callback),
+          disconnect: actualBridge.disconnect
+            ? async () => await actualBridge.disconnect()
+            : undefined
+        })
+      })
+    }
+
+    return wallets
+  }
+
   public destroy(): void {
     if (this.parentAPI) {
       this.parentAPI.eip6963Wallets = []
       this.parentAPI.walletStandardWallets = []
       this.parentAPI.tronWallets = []
+      this.parentAPI.tonWallets = []
       this.parentAPI = null
     }
     this.endpoint = null