@meshconnect/uwc-core 0.2.0

package/src/managers/session-manager.ts

@@ -0,0 +1,43 @@
+import type { Session, Network } from '@meshconnect/uwc-types'
+
+export class SessionManager {
+  private session: Session = {
+    connectionMode: null,
+    activeWallet: null,
+    activeNetwork: null,
+    activeAddress: null,
+    availableNetworks: [],
+    availableAddresses: []
+  }
+
+  getSession(): Session {
+    return this.session
+  }
+
+  updateSession(updates: Partial<Session>): void {
+    this.session = { ...this.session, ...updates }
+  }
+
+  setActiveNetwork(network: Network | null): void {
+    this.session.activeNetwork = network
+  }
+
+  setActiveAddress(address: string | null): void {
+    this.session.activeAddress = address
+  }
+
+  setAvailableNetworks(networks: Network[]): void {
+    this.session.availableNetworks = networks
+  }
+
+  clearSession(): void {
+    this.session = {
+      connectionMode: null,
+      activeWallet: null,
+      activeNetwork: null,
+      activeAddress: null,
+      availableNetworks: [],
+      availableAddresses: []
+    }
+  }
+}

package/src/services/connection-service.ts

@@ -0,0 +1,248 @@
+import type {
+  Network,
+  NetworkId,
+  WalletMetadata,
+  ConnectionMode,
+  Connector,
+  SupportedProvider,
+  ExtensionInjectedProvider,
+  IntegratedBrowserInjectedProvider,
+  WalletConnectProvider
+} from '@meshconnect/uwc-types'
+import type { SessionManager } from '../managers/session-manager'
+import type { EventManager } from '../managers/event-manager'
+
+export class ConnectionService {
+  private activeConnector: Connector | null = null
+
+  constructor(
+    private networks: Network[],
+    private wallets: WalletMetadata[],
+    private sessionManager: SessionManager,
+    private connectors: Map<ConnectionMode, Connector>,
+    private usingIntegratedBrowser: boolean,
+    private eventManager: EventManager
+  ) {}
+
+  async connect(
+    connectionMode: ConnectionMode,
+    walletId: string,
+    networkId?: NetworkId
+  ): Promise<void> {
+    // Find the wallet
+    const wallet = this.findWallet(walletId)
+
+    // Get the appropriate provider based on connection mode
+    const provider = this.getProviderForMode(wallet, connectionMode)
+
+    // Validate and determine the network
+    const network = this.validateAndDetermineNetwork(networkId, provider)
+
+    // Get the appropriate connector
+    const connector = this.getConnector(connectionMode)
+
+    // Store the active connector BEFORE starting connection
+    // This allows getConnectionURI to work while connection is in progress
+    this.activeConnector = connector
+
+    let result
+    if (connectionMode === 'injected') {
+      // For injected, pass the provider (which is ExtensionInjectedProvider | IntegratedBrowserInjectedProvider)
+      result = await connector.connect(
+        network,
+        provider as
+          | ExtensionInjectedProvider
+          | IntegratedBrowserInjectedProvider
+      )
+    } else if (connectionMode === 'walletConnect') {
+      // For WalletConnect, start connection and poll for URI
+      const connectPromise = connector.connect(
+        network,
+        provider as WalletConnectProvider
+      )
+
+      // Poll for URI and notify when it becomes available
+      const pollForURI = setInterval(() => {
+        const uri = this.getConnectionURI()
+        if (uri) {
+          clearInterval(pollForURI)
+          // Notify subscribers that URI is available
+          this.eventManager.notify()
+        }
+      }, 100) // Poll every 100ms
+
+      // Stop polling after 10 seconds
+      const timeoutId = setTimeout(() => {
+        clearInterval(pollForURI)
+      }, 10000)
+
+      try {
+        result = await connectPromise
+      } finally {
+        // Ensure cleanup happens regardless of success or failure
+        clearInterval(pollForURI)
+        clearTimeout(timeoutId)
+      }
+    } else {
+      throw new Error(`Unsupported connection mode: ${connectionMode}`)
+    }
+
+    // Filter available addresses to only include those for configured networks
+    const filteredAvailableAddresses = result.availableAddresses.filter(addr =>
+      this.networks.some(n => n.id === addr.networkId)
+    )
+
+    this.sessionManager.updateSession({
+      connectionMode,
+      activeWallet: wallet,
+      activeNetwork: network,
+      activeAddress: result.address,
+      availableNetworks: this.networks.filter(n =>
+        provider.supportedNetworkIds.includes(n.id)
+      ),
+      availableAddresses: filteredAvailableAddresses
+    })
+  }
+
+  private getConnector(connectionMode: ConnectionMode): Connector {
+    const connector = this.connectors.get(connectionMode)
+    if (!connector) {
+      throw new Error(
+        `No connector found for connection mode: ${connectionMode}`
+      )
+    }
+    return connector
+  }
+
+  private findWallet(walletId: string): WalletMetadata {
+    const wallet = this.wallets.find(w => w.id === walletId)
+    if (!wallet) {
+      throw new Error(`Wallet with id '${walletId}' not found`)
+    }
+    return wallet
+  }
+
+  private getProviderForMode(
+    wallet: WalletMetadata,
+    connectionMode: ConnectionMode
+  ): SupportedProvider {
+    let provider: SupportedProvider | undefined
+
+    if (connectionMode === 'injected') {
+      provider = this.usingIntegratedBrowser
+        ? wallet.integratedBrowserInjectedProvider
+        : wallet.extensionInjectedProvider
+
+      if (!provider) {
+        throw new Error(
+          this.usingIntegratedBrowser
+            ? `Wallet '${wallet.id}' does not have an integrated browser injected provider`
+            : `Wallet '${wallet.id}' does not have an extension injected provider`
+        )
+      }
+    } else if (connectionMode === 'walletConnect') {
+      provider = wallet.walletConnectProvider
+
+      if (!provider) {
+        throw new Error(
+          `Wallet '${wallet.id}' does not have a WalletConnect provider`
+        )
+      }
+    } else {
+      throw new Error(`Unsupported connection mode: ${connectionMode}`)
+    }
+
+    return provider
+  }
+
+  private validateAndDetermineNetwork(
+    networkId: NetworkId | undefined,
+    provider: SupportedProvider
+  ): Network {
+    let targetNetworkId: NetworkId
+
+    if (networkId) {
+      // Check if networkId is in the configured networks
+      const networkExists = this.networks.some(n => n.id === networkId)
+      if (!networkExists) {
+        throw new Error(
+          `Network ${networkId} is not in the configured networks`
+        )
+      }
+
+      // Check if networkId is supported by the wallet
+      const supportedByWallet = provider.supportedNetworkIds.includes(networkId)
+      if (!supportedByWallet) {
+        throw new Error(`Network ${networkId} is not supported by the wallet`)
+      }
+
+      targetNetworkId = networkId
+    } else {
+      // Use the first supported network that exists in both wallet and configured networks
+      const supportedNetwork = provider.supportedNetworkIds.find(id =>
+        this.networks.some(n => n.id === id)
+      )
+      if (!supportedNetwork) {
+        throw new Error(
+          'No common supported network found between wallet and configured networks'
+        )
+      }
+      targetNetworkId = supportedNetwork
+    }
+
+    // Find and return the network object
+    const network = this.networks.find(n => n.id === targetNetworkId)
+    if (!network) {
+      throw new Error(
+        `Network ${targetNetworkId} not found in configured networks`
+      )
+    }
+    return network
+  }
+
+  async disconnect(): Promise<void> {
+    // If there's an active connector with a disconnect method, call it
+    if (
+      this.activeConnector &&
+      typeof this.activeConnector.disconnect === 'function'
+    ) {
+      await this.activeConnector.disconnect()
+    }
+
+    // Clear the active connector
+    this.activeConnector = null
+
+    // Clear the session state
+    this.sessionManager.clearSession()
+  }
+
+  getConnectionURI(): string | undefined {
+    // Only WalletConnect connector has getConnectionURI method
+    if (
+      this.activeConnector &&
+      typeof this.activeConnector.getConnectionURI === 'function'
+    ) {
+      try {
+        const uri = this.activeConnector.getConnectionURI()
+        return uri
+      } catch {
+        // If there's no URI available yet, return undefined
+        return undefined
+      }
+    }
+
+    return undefined
+  }
+
+  getWallets(): WalletMetadata[] {
+    return this.wallets
+  }
+
+  updateWallets(wallets: WalletMetadata[]): void {
+    this.wallets = wallets
+  }
+
+  getNetworks(): Network[] {
+    return this.networks
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,3 @@
+export * from './connection-service'
+export * from './signature-service'
+export * from './transaction-service'

package/src/services/network-switch-service.ts

@@ -0,0 +1,182 @@
+import type {
+  Network,
+  NetworkId,
+  Connector,
+  ConnectionMode,
+  SupportedProvider,
+  WalletMetadata,
+  ExtensionInjectedProvider,
+  IntegratedBrowserInjectedProvider,
+  WalletConnectProvider
+} from '@meshconnect/uwc-types'
+import type { SessionManager } from '../managers/session-manager'
+import type { EventManager } from '../managers/event-manager'
+
+export class NetworkSwitchService {
+  private isLoading = false
+  private isWaitingForUserApproval = false
+
+  constructor(
+    private networks: Network[],
+    private sessionManager: SessionManager,
+    private connectors: Map<ConnectionMode, Connector>,
+    private usingIntegratedBrowser: boolean,
+    private eventManager: EventManager
+  ) {}
+
+  getLoadingState() {
+    return {
+      isLoading: this.isLoading,
+      isWaitingForUserApproval: this.isWaitingForUserApproval
+    }
+  }
+
+  async switchNetwork(networkId: NetworkId): Promise<void> {
+    // Check if there's an active connection
+    const session = this.sessionManager.getSession()
+    if (!session) {
+      throw new Error('No active connection. Connect to a wallet first.')
+    }
+
+    // Find the network
+    const network = this.networks.find(n => n.id === networkId)
+    if (!network) {
+      throw new Error(`Network with id '${networkId}' not found`)
+    }
+
+    // Check if the network is supported by the current wallet
+    const currentWallet = session.activeWallet
+    if (!currentWallet) {
+      throw new Error('No active wallet found in session')
+    }
+
+    // Check if connection mode is set
+    if (!session.connectionMode) {
+      throw new Error('No connection mode found in session')
+    }
+
+    // Get the provider for the current connection mode
+    let provider: SupportedProvider | undefined
+
+    if (session.connectionMode === 'injected') {
+      provider = this.usingIntegratedBrowser
+        ? currentWallet.integratedBrowserInjectedProvider
+        : currentWallet.extensionInjectedProvider
+    } else if (session.connectionMode === 'walletConnect') {
+      provider = currentWallet.walletConnectProvider
+    }
+
+    if (!provider) {
+      throw new Error(
+        `Wallet '${currentWallet.id}' does not have a provider for ${session.connectionMode} mode`
+      )
+    }
+
+    // Validate the network is supported by the wallet
+    if (!provider.supportedNetworkIds.includes(networkId)) {
+      throw new Error(
+        `Network ${networkId} is not supported by the current wallet`
+      )
+    }
+
+    // Get the active connector
+    const activeConnector = this.connectors.get(session.connectionMode)
+
+    // Check if the connector supports network switching
+    if (
+      !activeConnector ||
+      typeof activeConnector.switchNetwork !== 'function'
+    ) {
+      throw new Error('Current connector does not support network switching')
+    }
+
+    // Determine if user approval is required based on wallet metadata
+    const requiresApproval = this.checkIfApprovalRequired(
+      currentWallet,
+      network,
+      session.activeNetwork
+    )
+
+    try {
+      // Set loading states
+      this.isLoading = true
+      this.isWaitingForUserApproval = requiresApproval
+      this.eventManager.notify()
+
+      // Perform the network switch and get the new address
+      // Pass the appropriate provider based on connection mode
+      let result
+      if (session.connectionMode === 'injected' && provider) {
+        result = await activeConnector.switchNetwork(
+          network,
+          provider as
+            | ExtensionInjectedProvider
+            | IntegratedBrowserInjectedProvider
+        )
+      } else if (session.connectionMode === 'walletConnect' && provider) {
+        result = await activeConnector.switchNetwork(
+          network,
+          provider as WalletConnectProvider
+        )
+      } else {
+        result = await activeConnector.switchNetwork(network)
+      }
+
+      // Update the session with the new network, address, and available addresses
+      this.sessionManager.updateSession({
+        activeNetwork: network,
+        activeAddress: result.address,
+        ...(result.availableAddresses && {
+          availableAddresses: result.availableAddresses
+        })
+      })
+    } finally {
+      // Clear loading states
+      this.isLoading = false
+      this.isWaitingForUserApproval = false
+      this.eventManager.notify()
+    }
+  }
+
+  private checkIfApprovalRequired(
+    wallet: WalletMetadata,
+    targetNetwork: Network,
+    currentNetwork: Network | null
+  ): boolean {
+    if (!currentNetwork) return false
+
+    // Check if switching between different namespaces
+    const isNamespaceSwitch =
+      currentNetwork.namespace !== targetNetwork.namespace
+
+    // Get the provider to check metadata
+    const provider = this.usingIntegratedBrowser
+      ? wallet.integratedBrowserInjectedProvider
+      : wallet.extensionInjectedProvider
+
+    if (!provider) return false
+
+    // Check if namespace switch requires approval
+    if (isNamespaceSwitch && provider.requiresUserApprovalOnNamespaceSwitch) {
+      return true
+    }
+
+    // Check if network switch within same namespace requires approval
+    if (
+      !isNamespaceSwitch &&
+      provider.namespaceMetaData?.[targetNetwork.namespace]
+    ) {
+      const namespaceData = provider.namespaceMetaData[targetNetwork.namespace]
+      // Only EIP155 networks have the requiresUserApprovalOnNetworkSwitch property
+      if (
+        namespaceData &&
+        targetNetwork.namespace === 'eip155' &&
+        'requiresUserApprovalOnNetworkSwitch' in namespaceData
+      ) {
+        return namespaceData.requiresUserApprovalOnNetworkSwitch || false
+      }
+    }
+
+    return false
+  }
+}

package/src/services/signature-service.ts

@@ -0,0 +1,77 @@
+import type {
+  ConnectionMode,
+  Connector,
+  ExtensionInjectedProvider,
+  IntegratedBrowserInjectedProvider,
+  WalletConnectProvider,
+  SupportedProvider
+} from '@meshconnect/uwc-types'
+import type { SessionManager } from '../managers/session-manager'
+
+/**
+ * Service for handling signature operations across different connector types
+ */
+export class SignatureService {
+  constructor(
+    private sessionManager: SessionManager,
+    private connectors: Map<ConnectionMode, Connector>
+  ) {}
+
+  /**
+   * Sign a message with the currently connected wallet
+   * @param message The message to sign
+   * @param provider The wallet provider to use for signing (required for injected connector)
+   * @returns A promise that resolves to the signature
+   */
+  async signMessage(
+    message: string,
+    provider?: SupportedProvider
+  ): Promise<string> {
+    const session = this.sessionManager.getSession()
+
+    if (!session.connectionMode) {
+      throw new Error('No active connection')
+    }
+
+    if (!session.activeAddress) {
+      throw new Error('No active wallet address')
+    }
+
+    // Get the appropriate connector
+    const connector = this.connectors.get(session.connectionMode)
+    if (!connector) {
+      throw new Error(
+        `No connector found for connection mode: ${session.connectionMode}`
+      )
+    }
+
+    // Check if the connector supports signing
+    if (!connector.signMessage) {
+      throw new Error(`Connector does not support message signing`)
+    }
+
+    // Call the connector's signMessage method with the appropriate provider
+    if (session.connectionMode === 'injected') {
+      if (!provider) {
+        throw new Error('Provider is required for injected connector')
+      }
+      return await connector.signMessage(
+        message,
+        provider as
+          | ExtensionInjectedProvider
+          | IntegratedBrowserInjectedProvider
+      )
+    } else if (session.connectionMode === 'walletConnect') {
+      if (!provider) {
+        throw new Error('Provider is required for WalletConnect connector')
+      }
+      return await connector.signMessage(
+        message,
+        provider as WalletConnectProvider
+      )
+    } else {
+      // For other connectors that might not need the provider
+      return await connector.signMessage(message)
+    }
+  }
+}

package/src/services/transaction-service.ts

@@ -0,0 +1,79 @@
+import type {
+  ConnectionMode,
+  Connector,
+  ExtensionInjectedProvider,
+  IntegratedBrowserInjectedProvider,
+  WalletConnectProvider,
+  SupportedProvider,
+  TransactionRequest,
+  TransactionResult
+} from '@meshconnect/uwc-types'
+import type { SessionManager } from '../managers/session-manager'
+
+/**
+ * Service for handling transaction operations across different connector types
+ */
+export class TransactionService {
+  constructor(
+    private sessionManager: SessionManager,
+    private connectors: Map<ConnectionMode, Connector>
+  ) {}
+
+  /**
+   * Send a transaction with the currently connected wallet
+   * @param request The transaction request parameters
+   * @param provider The wallet provider to use for sending (required for injected connector)
+   * @returns A promise that resolves to the transaction result
+   */
+  async sendTransaction(
+    request: TransactionRequest,
+    provider?: SupportedProvider
+  ): Promise<TransactionResult> {
+    const session = this.sessionManager.getSession()
+
+    if (!session.connectionMode) {
+      throw new Error('No active connection')
+    }
+
+    if (!session.activeAddress) {
+      throw new Error('No active wallet address')
+    }
+
+    // Get the appropriate connector
+    const connector = this.connectors.get(session.connectionMode)
+    if (!connector) {
+      throw new Error(
+        `No connector found for connection mode: ${session.connectionMode}`
+      )
+    }
+
+    // Check if the connector supports transactions
+    if (!connector.sendTransaction) {
+      throw new Error(`Connector does not support transactions`)
+    }
+
+    // Call the connector's sendTransaction method with the appropriate provider
+    if (session.connectionMode === 'injected') {
+      if (!provider) {
+        throw new Error('Provider is required for injected connector')
+      }
+      return await connector.sendTransaction(
+        request,
+        provider as
+          | ExtensionInjectedProvider
+          | IntegratedBrowserInjectedProvider
+      )
+    } else if (session.connectionMode === 'walletConnect') {
+      if (!provider) {
+        throw new Error('Provider is required for WalletConnect connector')
+      }
+      return await connector.sendTransaction(
+        request,
+        provider as WalletConnectProvider
+      )
+    } else {
+      // For other connectors that might not need the provider
+      return await connector.sendTransaction(request)
+    }
+  }
+}