@meshconnect/uwc-injected-connector 0.2.6 → 0.2.8

package/src/services/solana/solana-wallet-service.ts

@@ -1,7 +1,7 @@
 import type { NetworkId, AvailableAddress } from '@meshconnect/uwc-types'
-import type { WalletAdapter } from '@solana/wallet-adapter-base'
 import {
   getSolanaWallets,
+  type SolanaAdapter,
   type WalletStandardInfo
 } from '../../wallet-standard-discovery'
 import { StorageService } from '../storage-service'
@@ -11,7 +11,7 @@ import { StorageService } from '../storage-service'
  */
 export class SolanaWalletService {
   private detectedWallets: WalletStandardInfo[] = []
-  private connectedAdapter: WalletAdapter | null = null
+  private connectedAdapter: SolanaAdapter | null = null
   private account: string | null = null
   private storageService: StorageService
 
@@ -22,8 +22,8 @@ export class SolanaWalletService {
   /**
    * Initialize wallet discovery
    */
-  initializeDiscovery(): void {
-    this.detectedWallets = getSolanaWallets()
+  async initializeDiscovery(): Promise<void> {
+    this.detectedWallets = await getSolanaWallets()
   }
 
   /**
@@ -44,30 +44,27 @@ export class SolanaWalletService {
    * Check if a Solana wallet is already connected
    */
   async checkExistingConnection(
-    adapter: WalletAdapter,
+    adapter: SolanaAdapter,
     walletUuid: string
   ): Promise<string | null> {
     try {
+      const base58PublicKey = await adapter.publicKey?.toBase58()
       // Check if adapter has a publicKey (means it's connected)
-      if (adapter.publicKey) {
-        return adapter.publicKey.toBase58()
+      if (base58PublicKey) {
+        return base58PublicKey
       }
 
       // If this wallet was previously connected, try to reconnect
       // This should work without prompting for wallets that support it
       if (this.storageService.wasSolanaWalletPreviouslyConnected(walletUuid)) {
-        if (
-          'connecting' in adapter &&
-          !adapter.connecting &&
-          'connect' in adapter
-        ) {
+        const walletIsConnecting = await adapter.connecting
+        if (!walletIsConnecting) {
           try {
-            // Type assertion needed because TypeScript can't narrow the type properly
             await adapter.connect()
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const publicKey = (adapter as any).publicKey
-            if (publicKey && 'toBase58' in publicKey) {
-              return publicKey.toBase58()
+
+            const base58PublicKey = await adapter.publicKey?.toBase58()
+            if (base58PublicKey) {
+              return base58PublicKey
             }
           } catch {
             // Silent fail - wallet requires user interaction or doesn't support silent reconnect
@@ -83,15 +80,16 @@ export class SolanaWalletService {
   /**
    * Connect to wallet
    */
-  async connect(adapter: WalletAdapter, walletUuid: string): Promise<string> {
+  async connect(adapter: SolanaAdapter, walletUuid: string): Promise<string> {
     // Connect to the Solana wallet
     await adapter.connect()
 
-    if (!adapter.publicKey) {
-      throw new Error('No public key returned from wallet')
+    const address = await adapter.publicKey?.toBase58()
+
+    if (!address) {
+      throw new Error('No address returned from wallet')
     }
 
-    const address = adapter.publicKey.toBase58()
     this.connectedAdapter = adapter
     this.account = address
 
@@ -124,7 +122,7 @@ export class SolanaWalletService {
    * Set connection state
    */
   setConnectionState(
-    adapter: WalletAdapter | null,
+    adapter: SolanaAdapter | null,
     account: string | null,
     walletUuid?: string
   ): void {
@@ -147,7 +145,7 @@ export class SolanaWalletService {
   /**
    * Get connected adapter
    */
-  getConnectedAdapter(): WalletAdapter | null {
+  getConnectedAdapter(): SolanaAdapter | null {
     return this.connectedAdapter
   }
 

package/src/services/transaction-service.ts

@@ -1,5 +1,4 @@
 import type { EthereumProvider } from '../eip6963-discovery'
-import type { WalletAdapter } from '@solana/wallet-adapter-base'
 import type {
   TransactionRequest,
   TransactionResult,
@@ -10,6 +9,7 @@ import type {
 import { EthereumTransactionService } from './ethereum/ethereum-transaction-service'
 import { SolanaTransactionService } from './solana/solana-transaction-service'
 import { parseError } from '../utils/error-utils'
+import type { SolanaAdapter } from '../wallet-standard-discovery'
 
 /**
  * Service for handling transaction operations across different wallet types
@@ -29,7 +29,7 @@ export class TransactionService {
   async sendTransaction(
     request: TransactionRequest,
     namespace: 'eip155' | 'solana',
-    provider: EthereumProvider | WalletAdapter
+    provider: EthereumProvider | SolanaAdapter
   ): Promise<TransactionResult> {
     if (namespace === 'eip155') {
       return await this.ethereumService.sendTransaction(
@@ -39,7 +39,7 @@ export class TransactionService {
     } else if (namespace === 'solana') {
       return await this.solanaService.sendTransaction(
         request as SolanaTransactionRequest,
-        provider as WalletAdapter
+        provider as SolanaAdapter
       )
     } else {
       throw parseError(new Error(`Unsupported namespace: ${namespace}`))

package/src/wallet-standard-discovery.ts

@@ -7,28 +7,97 @@
 import type { Wallet } from '@wallet-standard/base'
 import { getWallets } from '@wallet-standard/app'
 import { isWalletAdapterCompatibleStandardWallet } from '@solana/wallet-adapter-base'
-import type { WalletAdapter } from '@solana/wallet-adapter-base'
 import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-base'
-import { CoinbaseWalletAdapter } from '@solana/wallet-adapter-wallets'
+import type { Transaction } from '@solana/web3.js'
+
+export interface ExtendedStandardWalletAdapter extends StandardWalletAdapter {
+  customFunctions: (
+    | 'sendSerializedTransaction'
+    | 'signSerializedTransaction'
+    | 'signAllSerializedTransactions'
+  )[]
+  sendSerializedTransaction: (
+    transaction: unknown,
+    rpcUrl: string
+  ) => Promise<string>
+  signSerializedTransaction: (
+    transaction: unknown
+  ) => Promise<Error | Transaction>
+  signAllSerializedTransactions: (
+    transactions: unknown[]
+  ) => Promise<Error | Transaction[]>
+}
+
+export type SolanaAdapter =
+  | ExtendedStandardWalletAdapter
+  | StandardWalletAdapter
 
 export interface WalletStandardInfo {
   uuid: string
   name: string
   chains: string[]
   features: string[]
-  adapter: WalletAdapter | undefined
+  adapter: SolanaAdapter | undefined
 }
 
-export interface SolanaWalletWithAdapter {
-  info: WalletStandardInfo
-  wallet: Wallet
-  adapter?: WalletAdapter
+/**
+ * Polls for bridge wallets when UWCBridgeInitialized is true
+ * @returns Promise that resolves to an array of detected wallets from the bridge
+ */
+async function pollForBridgeWallets(): Promise<WalletStandardInfo[]> {
+  const pollInterval = 100 // Poll every 100ms
+  const maxPollTime = 3000 // Poll for maximum 3 seconds
+  const startTime = Date.now()
+
+  return new Promise(resolve => {
+    const poll = () => {
+      // Check if we've exceeded the max poll time
+      if (Date.now() - startTime > maxPollTime) {
+        resolve([])
+        return
+      }
+
+      // Check if window.walletStandardWallets is available
+      if (
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - window.eip6963Wallets is set by the bridge
+        window.walletStandardWallets &&
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - window.eip6963Wallets is set by the bridge
+        Array.isArray(window.walletStandardWallets)
+      ) {
+        const bridgeWallets =
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          window.walletStandardWallets as WalletStandardInfo[]
+        resolve(bridgeWallets)
+        return
+      }
+
+      // Continue polling
+      setTimeout(poll, pollInterval)
+    }
+
+    // Start polling
+    poll()
+  })
 }
 
 /**
  * Gets all available Solana wallets using Wallet Standard
  */
-export function getSolanaWallets(): WalletStandardInfo[] {
+export async function getSolanaWallets(): Promise<WalletStandardInfo[]> {
+  // UWCBridgeChildInitialized is only initialized if app runs in an iframe. We can skip checking for bridge proxy providers when it's not necessary.
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - window.UWCBridgeInitialized is set by the bridge
+  if (window.UWCBridgeChildInitialized === true) {
+    const wallets = await pollForBridgeWallets()
+
+    if (wallets.length > 0) {
+      return wallets
+    }
+  }
+
   const { get } = getWallets()
   const wallets = get()
 
@@ -56,30 +125,6 @@ export function getSolanaWallets(): WalletStandardInfo[] {
     }
   }
 
-  // Initialize traditional wallet adapters - Only import CBW for now, as it's not using Wallet Standard
-  const walletAdapters = [new CoinbaseWalletAdapter()]
-
-  // Add traditional wallet adapters (but skip duplicates)
-  for (const adapter of walletAdapters) {
-    if (walletNames.has(adapter.name)) {
-      // Skipping duplicate wallet already detected via Wallet Standard
-      continue
-    }
-
-    const readyState = adapter.readyState
-    const isDetected = readyState === 'Installed' || readyState === 'Loadable'
-
-    // Only add if installed
-    if (isDetected) {
-      solanaWallets.push({
-        uuid: `${adapter.name}-traditional`.toLowerCase().replace(/\s+/g, '-'),
-        name: adapter.name,
-        chains: ['solana:mainnet'],
-        features: [],
-        adapter: adapter
-      })
-    }
-  }
   return solanaWallets
 }