@meshconnect/uwc-bridge-parent 1.1.1 → 1.2.1

package/src/BaseWalletAdapter.test.ts

@@ -0,0 +1,371 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+
+// Mock @solana/wallet-adapter-base with a proper base class
+vi.mock('@solana/wallet-adapter-base', () => {
+  class MockBaseMessageSignerWalletAdapter {
+    _evtListeners: Record<string, ((...args: any[]) => void)[]> = {}
+
+    get connected() {
+      return !!(this as any)._publicKey
+    }
+
+    emit(event: string, ...args: any[]) {
+      for (const fn of this._evtListeners[event] || []) fn(...args)
+      return true
+    }
+
+    on(event: string, fn: (...args: any[]) => void) {
+      if (!this._evtListeners[event]) this._evtListeners[event] = []
+      this._evtListeners[event].push(fn)
+      return this
+    }
+
+    off(event: string, fn: (...args: any[]) => void) {
+      if (this._evtListeners[event]) {
+        this._evtListeners[event] = this._evtListeners[event].filter(
+          f => f !== fn
+        )
+      }
+      return this
+    }
+
+    async prepareTransaction(tx: any) {
+      return tx
+    }
+  }
+
+  return {
+    BaseMessageSignerWalletAdapter: MockBaseMessageSignerWalletAdapter,
+    isVersionedTransaction: vi.fn(() => false),
+    scopePollingDetectionStrategy: vi.fn(),
+    WalletAccountError: class extends Error {
+      override name = 'WalletAccountError'
+    },
+    WalletConnectionError: class extends Error {
+      override name = 'WalletConnectionError'
+      constructor(msg?: string) {
+        super(msg || 'WalletConnectionError')
+      }
+    },
+    WalletDisconnectedError: class extends Error {
+      override name = 'WalletDisconnectedError'
+    },
+    WalletDisconnectionError: class extends Error {
+      override name = 'WalletDisconnectionError'
+      constructor(msg?: string) {
+        super(msg || 'WalletDisconnectionError')
+      }
+    },
+    WalletError: class extends Error {},
+    WalletNotConnectedError: class extends Error {
+      override name = 'WalletNotConnectedError'
+    },
+    WalletNotReadyError: class extends Error {
+      override name = 'WalletNotReadyError'
+    },
+    WalletPublicKeyError: class extends Error {
+      override name = 'WalletPublicKeyError'
+      constructor(msg?: string) {
+        super(msg || 'WalletPublicKeyError')
+      }
+    },
+    WalletReadyState: {
+      Installed: 'Installed',
+      NotDetected: 'NotDetected',
+      Loadable: 'Loadable',
+      Unsupported: 'Unsupported'
+    },
+    WalletSendTransactionError: class extends Error {
+      override name = 'WalletSendTransactionError'
+      constructor(msg?: string) {
+        super(msg || 'WalletSendTransactionError')
+      }
+    },
+    WalletSignTransactionError: class extends Error {
+      override name = 'WalletSignTransactionError'
+      constructor(msg?: string) {
+        super(msg || 'WalletSignTransactionError')
+      }
+    }
+  }
+})
+
+vi.mock('@solana/web3.js', () => ({
+  PublicKey: class {
+    constructor(public _bytes: any) {}
+    toBase58() {
+      return 'mockBase58'
+    }
+    toBytes() {
+      return this._bytes
+    }
+    toJSON() {
+      return 'mockJSON'
+    }
+    toBuffer() {
+      return new Uint8Array([])
+    }
+    toString() {
+      return 'mockString'
+    }
+  }
+}))
+
+describe('BaseWalletAdapter', () => {
+  let mockWallet: any
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    mockWallet = {
+      publicKey: { toBytes: () => new Uint8Array([1, 2, 3]) },
+      connect: vi.fn().mockResolvedValue(undefined),
+      disconnect: vi.fn().mockResolvedValue(undefined),
+      signTransaction: vi.fn(async (tx: any) => tx),
+      signAllTransactions: vi.fn(async (txs: any) => txs),
+      signAndSendTransaction: vi
+        .fn()
+        .mockResolvedValue({ signature: 'mockSig' }),
+      signMessage: vi
+        .fn()
+        .mockResolvedValue({ signature: new Uint8Array([4, 5, 6]) }),
+      on: vi.fn(),
+      off: vi.fn()
+    }
+  })
+
+  afterEach(() => {
+    delete (window as any).coinbaseSolana
+    vi.restoreAllMocks()
+  })
+
+  async function createInstalledAdapter() {
+    const { scopePollingDetectionStrategy } =
+      await import('@solana/wallet-adapter-base')
+    const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+
+    ;(window as any).coinbaseSolana = mockWallet
+    const adapter = new BaseWalletAdapter()
+    const calls = vi.mocked(scopePollingDetectionStrategy).mock.calls
+    const callback = calls[calls.length - 1]![0] as () => boolean
+    callback()
+    return adapter
+  }
+
+  describe('constructor', () => {
+    it('should set correct name and properties', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      expect(adapter.name).toBe('Base Wallet')
+      expect(adapter.url).toContain('chrome.google.com')
+      expect(adapter.icon).toContain('data:image/svg+xml;base64,')
+      expect(adapter.publicKey).toBeNull()
+      expect(adapter.connecting).toBe(false)
+      expect(adapter.readyState).toBe('NotDetected')
+    })
+
+    it('should call scopePollingDetectionStrategy', async () => {
+      const { scopePollingDetectionStrategy } =
+        await import('@solana/wallet-adapter-base')
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+
+      new BaseWalletAdapter()
+
+      expect(scopePollingDetectionStrategy).toHaveBeenCalledWith(
+        expect.any(Function)
+      )
+    })
+
+    it('should detect wallet when window.coinbaseSolana exists', async () => {
+      const { scopePollingDetectionStrategy } =
+        await import('@solana/wallet-adapter-base')
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+
+      const adapter = new BaseWalletAdapter()
+      const mock = vi.mocked(scopePollingDetectionStrategy).mock
+      const callback = mock.calls[mock.calls.length - 1]![0] as () => boolean
+
+      expect(callback()).toBe(false)
+      ;(window as any).coinbaseSolana = mockWallet
+      expect(callback()).toBe(true)
+      expect(adapter.readyState).toBe('Installed')
+    })
+  })
+
+  describe('connect', () => {
+    it('should throw WalletNotReadyError when not installed', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      await expect(adapter.connect()).rejects.toThrow()
+    })
+
+    it('should connect successfully when installed', async () => {
+      const adapter = await createInstalledAdapter()
+
+      await adapter.connect()
+
+      expect(mockWallet.connect).toHaveBeenCalled()
+      expect(adapter.publicKey).toBeDefined()
+      expect(adapter.connecting).toBe(false)
+    })
+
+    it('should emit connect event on success', async () => {
+      const adapter = await createInstalledAdapter()
+      const connectHandler = vi.fn()
+      adapter.on('connect', connectHandler)
+
+      await adapter.connect()
+
+      expect(connectHandler).toHaveBeenCalled()
+    })
+
+    it('should throw when wallet.connect fails', async () => {
+      mockWallet.connect.mockRejectedValue(new Error('Connection failed'))
+      const adapter = await createInstalledAdapter()
+
+      await expect(adapter.connect()).rejects.toThrow()
+    })
+
+    it('should throw when no publicKey after connect', async () => {
+      mockWallet.publicKey = null
+      const adapter = await createInstalledAdapter()
+
+      await expect(adapter.connect()).rejects.toThrow()
+    })
+
+    it('should return early if already connected', async () => {
+      const adapter = await createInstalledAdapter()
+
+      await adapter.connect()
+      await adapter.connect()
+
+      expect(mockWallet.connect).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('disconnect', () => {
+    it('should clear state on disconnect', async () => {
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      await adapter.disconnect()
+
+      expect(adapter.publicKey).toBeNull()
+      expect(mockWallet.disconnect).toHaveBeenCalled()
+    })
+
+    it('should emit disconnect event', async () => {
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      const handler = vi.fn()
+      adapter.on('disconnect', handler)
+
+      await adapter.disconnect()
+
+      expect(handler).toHaveBeenCalled()
+    })
+
+    it('should handle wallet.disconnect error gracefully', async () => {
+      mockWallet.disconnect.mockRejectedValue(new Error('fail'))
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      await expect(adapter.disconnect()).resolves.toBeUndefined()
+    })
+
+    it('should emit disconnect even when no wallet connected', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      const handler = vi.fn()
+      adapter.on('disconnect', handler)
+
+      await adapter.disconnect()
+
+      expect(handler).toHaveBeenCalled()
+    })
+  })
+
+  describe('signTransaction', () => {
+    it('should throw when not connected', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      await expect(adapter.signTransaction({} as any)).rejects.toThrow()
+    })
+
+    it('should call wallet.signTransaction when connected', async () => {
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      const mockTx = { mock: true } as any
+      await adapter.signTransaction(mockTx)
+
+      expect(mockWallet.signTransaction).toHaveBeenCalledWith(mockTx)
+    })
+  })
+
+  describe('signAllTransactions', () => {
+    it('should throw when not connected', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      await expect(adapter.signAllTransactions([{} as any])).rejects.toThrow()
+    })
+
+    it('should call wallet.signAllTransactions when connected', async () => {
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      const mockTxs = [{ mock: 1 }, { mock: 2 }] as any[]
+      await adapter.signAllTransactions(mockTxs)
+
+      expect(mockWallet.signAllTransactions).toHaveBeenCalledWith(mockTxs)
+    })
+  })
+
+  describe('signMessage', () => {
+    it('should throw when not connected', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      await expect(adapter.signMessage(new Uint8Array([1]))).rejects.toThrow()
+    })
+
+    it('should return signature when connected', async () => {
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      const result = await adapter.signMessage(new Uint8Array([1, 2, 3]))
+
+      expect(mockWallet.signMessage).toHaveBeenCalled()
+      expect(result).toEqual(new Uint8Array([4, 5, 6]))
+    })
+  })
+
+  describe('sendTransaction', () => {
+    it('should throw when not connected', async () => {
+      const { BaseWalletAdapter } = await import('./BaseWalletAdapter')
+      const adapter = new BaseWalletAdapter()
+
+      await expect(
+        adapter.sendTransaction({} as any, {} as any)
+      ).rejects.toThrow()
+    })
+
+    it('should return signature when connected', async () => {
+      const adapter = await createInstalledAdapter()
+      await adapter.connect()
+
+      const mockTx = {} as any
+      const mockConnection = { commitment: 'confirmed' } as any
+      const result = await adapter.sendTransaction(mockTx, mockConnection)
+
+      expect(mockWallet.signAndSendTransaction).toHaveBeenCalled()
+      expect(result).toBe('mockSig')
+    })
+  })
+})

package/src/BaseWalletAdapter.ts

@@ -0,0 +1,295 @@
+import type {
+  EventEmitter,
+  SendTransactionOptions,
+  WalletName
+} from '@solana/wallet-adapter-base'
+import {
+  BaseMessageSignerWalletAdapter,
+  isVersionedTransaction,
+  scopePollingDetectionStrategy,
+  WalletAccountError,
+  WalletConnectionError,
+  WalletDisconnectedError,
+  WalletDisconnectionError,
+  WalletError,
+  WalletNotConnectedError,
+  WalletNotReadyError,
+  WalletPublicKeyError,
+  WalletReadyState,
+  WalletSendTransactionError,
+  WalletSignTransactionError,
+  WalletSignMessageError
+} from '@solana/wallet-adapter-base'
+import type {
+  Connection,
+  SendOptions,
+  Transaction,
+  VersionedTransaction,
+  TransactionSignature,
+  TransactionVersion
+} from '@solana/web3.js'
+import { PublicKey } from '@solana/web3.js'
+
+interface CoinbaseWalletEvents {
+  connect(...args: unknown[]): unknown
+  disconnect(...args: unknown[]): unknown
+}
+
+interface CoinbaseWallet extends EventEmitter<CoinbaseWalletEvents> {
+  publicKey?: PublicKey
+  signTransaction<T extends Transaction | VersionedTransaction>(
+    transaction: T
+  ): Promise<T>
+  signAllTransactions<T extends Transaction | VersionedTransaction>(
+    transactions: T[]
+  ): Promise<T[]>
+  signAndSendTransaction<T extends Transaction | VersionedTransaction>(
+    transaction: T,
+    options?: SendOptions
+  ): Promise<{ signature: TransactionSignature }>
+  signMessage(message: Uint8Array): Promise<{ signature: Uint8Array }>
+  connect(): Promise<void>
+  disconnect(): Promise<void>
+}
+
+interface CoinbaseWindow extends Window {
+  coinbaseSolana?: CoinbaseWallet
+}
+
+declare const window: CoinbaseWindow
+
+export const BaseWalletName = 'Base Wallet' as WalletName<'Base Wallet'>
+
+export class BaseWalletAdapter extends BaseMessageSignerWalletAdapter {
+  name = BaseWalletName
+  url =
+    'https://chrome.google.com/webstore/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad'
+  icon =
+    'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNCIgaGVpZ2h0PSIxMDI0IiB2aWV3Qm94PSIwIDAgMTAyNCAxMDI0IiBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8Y2lyY2xlIGN4PSI1MTIiIGN5PSI1MTIiIHI9IjUxMiIgZmlsbD0iIzAwNTJGRiIvPgo8cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTE1MiA1MTJDMTUyIDcxMC44MjMgMzEzLjE3NyA4NzIgNTEyIDg3MkM3MTAuODIzIDg3MiA4NzIgNzEwLjgyMyA4NzIgNTEyQzg3MiAzMTMuMTc3IDcxMC44MjMgMTUyIDUxMiAxNTJDMzEzLjE3NyAxNTIgMTUyIDMxMy4xNzcgMTUyIDUxMlpNNDIwIDM5NkM0MDYuNzQ1IDM5NiAzOTYgNDA2Ljc0NSAzOTYgNDIwVjYwNEMzOTYgNjE3LjI1NSA0MDYuNzQ1IDYyOCA0MjAgNjI4SDYwNEM2MTcuMjU1IDYyOCA2MjggNjE3LjI1NSA2MjggNjA0VjQyMEM2MjggNDA2Ljc0NSA2MTcuMjU1IDM5NiA2MDQgMzk2SDQyMFoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo='
+  supportedTransactionVersions: ReadonlySet<TransactionVersion> = new Set([
+    'legacy',
+    0
+  ])
+
+  private _connecting: boolean
+  private _wallet: CoinbaseWallet | null
+  private _publicKey: PublicKey | null
+  private _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.Unsupported
+      : WalletReadyState.NotDetected
+
+  constructor() {
+    super()
+    this._connecting = false
+    this._wallet = null
+    this._publicKey = null
+
+    if (this._readyState !== WalletReadyState.Unsupported) {
+      scopePollingDetectionStrategy(() => {
+        if (window?.coinbaseSolana) {
+          this._readyState = WalletReadyState.Installed
+          this.emit('readyStateChange', this._readyState)
+          return true
+        }
+        return false
+      })
+    }
+  }
+
+  get publicKey() {
+    return this._publicKey
+  }
+
+  get connecting() {
+    return this._connecting
+  }
+
+  get readyState() {
+    return this._readyState
+  }
+
+  async connect(): Promise<void> {
+    try {
+      if (this.connected || this.connecting) return
+      if (this._readyState !== WalletReadyState.Installed)
+        throw new WalletNotReadyError()
+
+      this._connecting = true
+
+      const wallet = window.coinbaseSolana!
+
+      try {
+        await wallet.connect()
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        throw new WalletConnectionError(error?.message, error)
+      }
+
+      if (!wallet.publicKey) throw new WalletAccountError()
+
+      let publicKey: PublicKey
+      try {
+        publicKey = new PublicKey(wallet.publicKey.toBytes())
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        throw new WalletPublicKeyError(error?.message, error)
+      }
+
+      wallet.on('disconnect', this._disconnected)
+
+      this._wallet = wallet
+      this._publicKey = publicKey
+
+      this.emit('connect', publicKey)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      this.emit('error', error)
+      throw error
+    } finally {
+      this._connecting = false
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    const wallet = this._wallet
+    if (wallet) {
+      wallet.off('disconnect', this._disconnected)
+
+      this._wallet = null
+      this._publicKey = null
+
+      try {
+        await wallet.disconnect()
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        this.emit('error', new WalletDisconnectionError(error?.message, error))
+      }
+    }
+
+    this.emit('disconnect')
+  }
+
+  override async sendTransaction<T extends Transaction | VersionedTransaction>(
+    transaction: T,
+    connection: Connection,
+    options: SendTransactionOptions = {}
+  ): Promise<TransactionSignature> {
+    try {
+      const wallet = this._wallet
+      if (!wallet) throw new WalletNotConnectedError()
+
+      try {
+        const { signers, ...sendOptions } = options
+
+        if (isVersionedTransaction(transaction)) {
+          if (signers?.length) transaction.sign(signers)
+        } else {
+          if (!(transaction as Transaction).recentBlockhash) {
+            transaction = (await this.prepareTransaction(
+              transaction,
+              connection,
+              sendOptions
+            )) as T
+          }
+
+          if (signers?.length)
+            (transaction as Transaction).partialSign(...signers)
+        }
+
+        if (!sendOptions.preflightCommitment && connection.commitment) {
+          sendOptions.preflightCommitment = connection.commitment
+        }
+
+        const { signature } = await wallet.signAndSendTransaction(
+          transaction,
+          sendOptions
+        )
+        return signature
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        if (error instanceof WalletError) throw error
+        throw new WalletSendTransactionError(error?.message, error)
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      this.emit('error', error)
+      throw error
+    }
+  }
+
+  async signTransaction<T extends Transaction | VersionedTransaction>(
+    transaction: T
+  ): Promise<T> {
+    try {
+      const wallet = this._wallet
+      if (!wallet) throw new WalletNotConnectedError()
+
+      try {
+        return ((await wallet.signTransaction(transaction)) as T) || transaction
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error?.message, error)
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      this.emit('error', error)
+      throw error
+    }
+  }
+
+  override async signAllTransactions<
+    T extends Transaction | VersionedTransaction
+  >(transactions: T[]): Promise<T[]> {
+    try {
+      const wallet = this._wallet
+      if (!wallet) throw new WalletNotConnectedError()
+
+      try {
+        return (
+          ((await wallet.signAllTransactions(transactions)) as T[]) ||
+          transactions
+        )
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        throw new WalletSignTransactionError(error?.message, error)
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      this.emit('error', error)
+      throw error
+    }
+  }
+
+  async signMessage(message: Uint8Array): Promise<Uint8Array> {
+    try {
+      const wallet = this._wallet
+      if (!wallet) throw new WalletNotConnectedError()
+
+      try {
+        const { signature } = await wallet.signMessage(message)
+        return signature
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (error: any) {
+        throw new WalletSignMessageError(error?.message, error)
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      this.emit('error', error)
+      throw error
+    }
+  }
+
+  private _disconnected = () => {
+    const wallet = this._wallet
+    if (wallet) {
+      wallet.off('disconnect', this._disconnected)
+
+      this._wallet = null
+      this._publicKey = null
+
+      this.emit('error', new WalletDisconnectedError())
+      this.emit('disconnect')
+    }
+  }
+}