@meshconnect/web-link-sdk 3.2.14 → 3.2.15

package/src/utils/connectors/evm/walletConnection.ts

@@ -0,0 +1,140 @@
+import { ethers } from 'ethers'
+import { EVMProvider, EVMConnectResult, EIP6963ProviderDetail } from './types'
+import {
+  setActiveEVMProvider,
+  getActiveRawProvider,
+  clearActiveProviders
+} from './provider'
+import { switchEVMChain } from './chainSwitching'
+import {
+  initializeWalletDiscovery,
+  findAvailableProviders
+} from './walletDiscovery'
+
+// Extend Window interface
+declare global {
+  interface Window {
+    ethereum?: EVMProvider & {
+      providers?: EVMProvider[]
+    }
+  }
+}
+
+initializeWalletDiscovery()
+
+/**
+ * Gets an EVM provider for a specific wallet
+ */
+export const getEVMProvider = (
+  walletName?: string,
+  walletDetail?: EIP6963ProviderDetail
+): EVMProvider => {
+  if (walletDetail?.provider) {
+    return walletDetail.provider as EVMProvider
+  }
+
+  if (!walletName) {
+    throw new Error('Wallet name is required')
+  }
+
+  const providers = findAvailableProviders()
+
+  const matchingProvider = providers.find(
+    p =>
+      p.name.toLowerCase() === walletName.toLowerCase() ||
+      p.name.toLowerCase().includes(walletName.toLowerCase())
+  )
+
+  if (matchingProvider) {
+    return matchingProvider.injectedData.provider
+  }
+
+  if (window.ethereum) {
+    return window.ethereum
+  }
+
+  throw new Error(
+    `No provider found for wallet ${walletName}. Please make sure the wallet is installed and enabled.`
+  )
+}
+
+/**
+ * Connects to an EVM wallet
+ */
+export const connectToEVMWallet = async (
+  walletName: string,
+  targetChainId?: number,
+  walletDetail?: EIP6963ProviderDetail
+): Promise<EVMConnectResult | Error> => {
+  try {
+    let provider: EVMProvider
+    try {
+      provider = getEVMProvider(walletName, walletDetail)
+    } catch (error) {
+      throw new Error(`No provider found for wallet ${walletName}`)
+    }
+
+    const browserProvider = new ethers.BrowserProvider(provider)
+    setActiveEVMProvider(browserProvider, provider)
+
+    let existingAccounts
+    try {
+      existingAccounts = await provider.request({ method: 'eth_accounts' })
+    } catch (error) {
+      existingAccounts = []
+    }
+    if (!existingAccounts || existingAccounts.length === 0) {
+      await browserProvider.send('eth_requestAccounts', [])
+    }
+
+    const signer = await browserProvider.getSigner()
+    const address = await signer.getAddress()
+    let chainId = await browserProvider
+      .getNetwork()
+      .then(network => Number(network.chainId))
+
+    if (targetChainId && chainId !== targetChainId) {
+      const switchResult = await switchEVMChain(targetChainId, provider)
+      if (switchResult instanceof Error) {
+        throw switchResult
+      }
+      chainId = switchResult.chainId
+    }
+
+    return {
+      accounts: [address],
+      chainId,
+      isConnected: true
+    }
+  } catch (error) {
+    console.error('EVM wallet connection error:', error)
+    return error instanceof Error
+      ? error
+      : new Error(`Failed to connect to ${walletName} wallet`)
+  }
+}
+
+/**
+ * Disconnects from an EVM wallet
+ */
+export const disconnectFromEVMWallet = async (
+  walletName: string
+): Promise<void | Error> => {
+  try {
+    const provider = getActiveRawProvider()
+    if (!provider) {
+      return
+    }
+
+    if (provider.removeAllListeners) {
+      provider.removeAllListeners()
+    }
+
+    clearActiveProviders()
+  } catch (error) {
+    console.error('EVM wallet disconnection error:', error)
+    return error instanceof Error
+      ? error
+      : new Error(`Failed to disconnect from ${walletName} wallet`)
+  }
+}

package/src/utils/connectors/evm/walletDiscovery.ts

@@ -0,0 +1,67 @@
+import {
+  EVMProvider,
+  InjectedProviderInfo,
+  EIP6963ProviderDetail
+} from './types'
+
+let discoveredWallets: EIP6963ProviderDetail[] = []
+
+/**
+ * Initializes EIP-6963 wallet discovery protocol
+ * @returns Cleanup function for event listeners
+ */
+export const initializeWalletDiscovery = (): (() => void) => {
+  const handleAnnouncement = (event: CustomEvent) => {
+    const providerDetail = event.detail as EIP6963ProviderDetail
+    discoveredWallets = [...discoveredWallets, providerDetail]
+  }
+
+  window.addEventListener(
+    'eip6963:announceProvider',
+    handleAnnouncement as EventListener
+  )
+  window.dispatchEvent(new Event('eip6963:requestProvider'))
+
+  return () => {
+    window.removeEventListener(
+      'eip6963:announceProvider',
+      handleAnnouncement as EventListener
+    )
+  }
+}
+
+/**
+ * Finds all available EVM providers using EIP-6963
+ */
+export const findAvailableProviders = (): InjectedProviderInfo[] => {
+  const providers: InjectedProviderInfo[] = []
+
+  // Initialize wallet discovery if not already done
+  if (discoveredWallets.length === 0) {
+    initializeWalletDiscovery()
+  }
+
+  // Add EIP-6963 discovered wallets
+  discoveredWallets.forEach(wallet => {
+    const injectedData: any = {
+      provider: wallet.provider as EVMProvider
+    }
+
+    // Copy all boolean properties that start with 'is'
+    for (const key in wallet.provider) {
+      const provider = wallet.provider as unknown as { [key: string]: unknown }
+      if (key.startsWith('is') && typeof provider[key] === 'boolean') {
+        injectedData[key] = provider[key]
+      }
+    }
+
+    providers.push({
+      name: wallet.info.name,
+      id: wallet.info.uuid,
+      icon: wallet.info.icon,
+      injectedData
+    })
+  })
+
+  return providers
+}

package/src/utils/connectors/solana/connection.ts

@@ -0,0 +1,69 @@
+import { SolanaConnectResult } from './types'
+import { getSolanaProvider } from './providerDiscovery'
+import { Buffer } from 'buffer'
+import { WalletBrowserPayload } from '../../types'
+
+if (typeof window !== 'undefined') {
+  window.Buffer = window.Buffer || Buffer
+}
+
+export const connectToSolanaWallet = async (
+  walletPayload: WalletBrowserPayload
+): Promise<SolanaConnectResult | Error> => {
+  try {
+    const provider = getSolanaProvider(walletPayload.integrationName)
+
+    // Try eager connect first, fall back to regular connect
+    const response = await provider
+      .connect({ onlyIfTrusted: true })
+      .catch(() => provider.connect())
+
+    // Handle Phantom wallet which returns response.publicKey
+    if (response?.publicKey) {
+      if (walletPayload.targetChainId == '103') {
+        return {
+          accounts: [response.publicKey.toString()],
+          chainId: '103',
+          isConnected: true
+        }
+      }
+      return {
+        accounts: [response.publicKey.toString()],
+        chainId: '101',
+        isConnected: true
+      }
+    }
+
+    // Handle other wallets that update provider.publicKey directly
+    if (provider.publicKey) {
+      return {
+        accounts: [provider.publicKey.toString()],
+        chainId: '101',
+        isConnected: true
+      }
+    }
+
+    throw new Error(
+      `${walletPayload.integrationName} connection failed - no public key returned`
+    )
+  } catch (error) {
+    return error instanceof Error
+      ? error
+      : new Error(
+          `Failed to connect to ${walletPayload.integrationName} wallet`
+        )
+  }
+}
+
+export const disconnectFromSolanaWallet = async (
+  walletName: string
+): Promise<void | Error> => {
+  try {
+    const provider = getSolanaProvider(walletName)
+    await provider.disconnect()
+  } catch (error) {
+    return error instanceof Error
+      ? error
+      : new Error(`Failed to disconnect from ${walletName} wallet`)
+  }
+}

package/src/utils/connectors/solana/index.ts

@@ -0,0 +1,5 @@
+export * from './types'
+export * from './providerDiscovery'
+export * from './connection'
+export * from './transaction'
+export * from './signing'

package/src/utils/connectors/solana/providerDiscovery.ts

@@ -0,0 +1,153 @@
+import {
+  SolanaProvider,
+  WindowWithSolanaProviders,
+  SolanaWalletType
+} from './types'
+
+declare const window: WindowWithSolanaProviders
+
+const identifyWalletType = (
+  provider: SolanaProvider & { [key: string]: any }
+): SolanaWalletType => {
+  if (provider.isPhantom) return SolanaWalletType.PHANTOM
+  if (provider.isSolflare) return SolanaWalletType.SOLFLARE
+  if (provider.isTrust || provider.isTrustWallet) return SolanaWalletType.TRUST
+  if (provider.isExodus) return SolanaWalletType.EXODUS
+  return SolanaWalletType.UNKNOWN
+}
+
+// Type-safe validation functions
+type WalletValidationFn = (provider: SolanaProvider) => boolean
+
+const walletValidations: Record<SolanaWalletType, WalletValidationFn> = {
+  [SolanaWalletType.PHANTOM]: (provider: SolanaProvider): boolean =>
+    provider.isPhantom === true &&
+    provider.isSolflare !== true &&
+    provider.isTrust !== true &&
+    provider.isTrustWallet !== true &&
+    provider.isExodus !== true,
+
+  [SolanaWalletType.SOLFLARE]: (provider: SolanaProvider): boolean =>
+    provider.isSolflare === true &&
+    provider.isPhantom !== true &&
+    provider.isTrust !== true &&
+    provider.isTrustWallet !== true &&
+    provider.isExodus !== true,
+
+  [SolanaWalletType.TRUST]: (provider: SolanaProvider): boolean =>
+    (provider.isTrust === true || provider.isTrustWallet === true) &&
+    provider.isPhantom !== true &&
+    provider.isSolflare !== true &&
+    provider.isExodus !== true,
+
+  [SolanaWalletType.EXODUS]: (provider: SolanaProvider): boolean =>
+    provider.isExodus === true &&
+    provider.isSolflare !== true &&
+    provider.isTrust !== true &&
+    provider.isTrustWallet !== true,
+  // Note: Exodus may also inject isPhantom, so we don't exclude it
+
+  [SolanaWalletType.UNKNOWN]: (provider: SolanaProvider): boolean =>
+    provider.isPhantom !== true &&
+    provider.isSolflare !== true &&
+    provider.isTrust !== true &&
+    provider.isTrustWallet !== true &&
+    provider.isExodus !== true
+}
+
+const getProviderByType = (
+  type: SolanaWalletType
+): SolanaProvider | undefined => {
+  // Then check known provider locations
+  switch (type) {
+    case SolanaWalletType.PHANTOM:
+      if (
+        window.phantom?.solana &&
+        walletValidations[type](window.phantom.solana)
+      ) {
+        return window.phantom.solana
+      }
+      return undefined
+    case SolanaWalletType.SOLFLARE:
+      if (window.solflare && walletValidations[type](window.solflare)) {
+        return window.solflare
+      }
+      return undefined
+    case SolanaWalletType.TRUST:
+      if (
+        window.trustwallet?.solana &&
+        walletValidations[type](window.trustwallet.solana)
+      ) {
+        return window.trustwallet.solana
+      }
+      return undefined
+    case SolanaWalletType.EXODUS:
+      if (
+        window.exodus?.solana &&
+        walletValidations[type](window.exodus.solana)
+      ) {
+        return window.exodus.solana
+      }
+      return undefined
+    case SolanaWalletType.UNKNOWN:
+      if (window.solana && walletValidations[type](window.solana)) {
+        return window.solana
+      }
+      return undefined
+    default:
+      return undefined
+  }
+}
+
+export const findAvailableSolanaProviders = (): {
+  [key in SolanaWalletType]?: boolean
+} => {
+  const providers: { [key in SolanaWalletType]?: boolean } = {}
+
+  // Check all known wallet types
+  Object.values(SolanaWalletType).forEach(type => {
+    if (getProviderByType(type)) {
+      providers[type] = true
+    }
+  })
+
+  // Also check window.solana if not already found
+  if (window.solana && !Object.keys(providers).length) {
+    const walletType = identifyWalletType(window.solana)
+    providers[walletType] = true
+  }
+
+  return providers
+}
+
+export const getSolanaProvider = (walletName: string): SolanaProvider => {
+  const normalizedName = walletName
+    .toLowerCase()
+    .replace(/\s+/g, '') as SolanaWalletType
+  const availableProviders = findAvailableSolanaProviders()
+
+  // First check if the requested wallet is available
+  if (availableProviders[normalizedName]) {
+    const provider = getProviderByType(normalizedName)
+    if (provider) return provider
+  }
+
+  // If not found and it's a dynamic provider, try direct access
+  const dynamicProvider = (window as any)[normalizedName]?.solana
+  if (dynamicProvider) {
+    return dynamicProvider
+  }
+
+  // If still not found, check window.solana as last resort
+  if (window.solana) {
+    const detectedType = identifyWalletType(window.solana)
+    if (
+      detectedType === normalizedName ||
+      normalizedName === SolanaWalletType.UNKNOWN
+    ) {
+      return window.solana
+    }
+  }
+
+  throw new Error(`Provider not found for wallet: ${walletName}`)
+}

package/src/utils/connectors/solana/signing.ts

@@ -0,0 +1,18 @@
+import bs58 from 'bs58'
+import { getSolanaProvider } from './providerDiscovery'
+
+export const signSolanaMessage = async (
+  walletName: string,
+  message: string
+): Promise<string | Error> => {
+  try {
+    const provider = getSolanaProvider(walletName)
+    const messageBytes = new TextEncoder().encode(message)
+    const signedMessage = await provider.signMessage(messageBytes)
+    return bs58.encode(signedMessage.signature)
+  } catch (error) {
+    return error instanceof Error
+      ? error
+      : new Error(`Failed to sign message with ${walletName} wallet`)
+  }
+}