@meshconnect/uwc-wallet-connect-connector 0.2.0

package/dist/utils/error-utils.js

@@ -0,0 +1,55 @@
+import { WalletConnectorError } from '@meshconnect/uwc-types';
+/**
+ * Parse an error and throw a WalletConnectorError
+ * Detects if the error is a user rejection or an unknown error
+ */
+export function parseError(error) {
+    let message;
+    let isRejected = false;
+    // Handle different error formats
+    if (error && typeof error === 'object') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const errorObj = error;
+        // Check for EIP-1193 error code
+        if (errorObj.code === 4001 || errorObj.code === 'ACTION_REJECTED') {
+            isRejected = true;
+        }
+        // Extract message
+        if (errorObj.message) {
+            message = errorObj.message;
+        }
+        else if (errorObj.error?.message) {
+            message = errorObj.error.message;
+        }
+        else {
+            message = String(error);
+        }
+    }
+    else {
+        message = String(error);
+    }
+    // If not already marked as rejected, check message patterns
+    if (!isRejected) {
+        const rejectionPatterns = [
+            'user rejected',
+            'user denied',
+            'user cancelled',
+            'user canceled',
+            'rejected by user',
+            'denied by user',
+            'cancelled by user',
+            'canceled by user',
+            'user disapproved',
+            'user declined',
+            'action_rejected'
+        ];
+        const lowerMessage = message.toLowerCase();
+        isRejected = rejectionPatterns.some(pattern => lowerMessage.includes(pattern.toLowerCase()));
+    }
+    const walletError = {
+        type: isRejected ? 'rejected' : 'unknown',
+        message
+    };
+    throw new WalletConnectorError(walletError);
+}
+//# sourceMappingURL=error-utils.js.map

package/dist/utils/error-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-utils.js","sourceRoot":"","sources":["../../src/utils/error-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAE7D;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,IAAI,OAAe,CAAA;IACnB,IAAI,UAAU,GAAG,KAAK,CAAA;IAEtB,iCAAiC;IACjC,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvC,8DAA8D;QAC9D,MAAM,QAAQ,GAAG,KAAY,CAAA;QAE7B,gCAAgC;QAChC,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAClE,UAAU,GAAG,IAAI,CAAA;QACnB,CAAC;QAED,kBAAkB;QAClB,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;YACrB,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAA;QAC5B,CAAC;aAAM,IAAI,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC;YACnC,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAA;QAClC,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;QACzB,CAAC;IACH,CAAC;SAAM,CAAC;QACN,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC;IAED,4DAA4D;IAC5D,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,iBAAiB,GAAG;YACxB,eAAe;YACf,aAAa;YACb,gBAAgB;YAChB,eAAe;YACf,kBAAkB;YAClB,gBAAgB;YAChB,mBAAmB;YACnB,kBAAkB;YAClB,kBAAkB;YAClB,eAAe;YACf,iBAAiB;SAClB,CAAA;QAED,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAA;QAC1C,UAAU,GAAG,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAC5C,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAC7C,CAAA;IACH,CAAC;IAED,MAAM,WAAW,GAAgB;QAC/B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;QACzC,OAAO;KACR,CAAA;IAED,MAAM,IAAI,oBAAoB,CAAC,WAAW,CAAC,CAAA;AAC7C,CAAC"}

package/dist/utils/solana-transactions.d.ts

@@ -0,0 +1,4 @@
+import type { SolanaNativeTransferRequest } from '@meshconnect/uwc-types';
+import { Transaction } from '@solana/web3.js';
+export declare function getSolanaTransaction(params: SolanaNativeTransferRequest): Transaction;
+//# sourceMappingURL=solana-transactions.d.ts.map

package/dist/utils/solana-transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana-transactions.d.ts","sourceRoot":"","sources":["../../src/utils/solana-transactions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAGL,WAAW,EAEZ,MAAM,iBAAiB,CAAA;AAExB,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,2BAA2B,eAevE"}

package/dist/utils/solana-transactions.js

@@ -0,0 +1,15 @@
+import { PublicKey, SystemProgram, Transaction, VersionedTransaction } from '@solana/web3.js';
+export function getSolanaTransaction(params) {
+    if (!params.blockhash) {
+        throw new Error('Blockhash is required for Solana transactions');
+    }
+    const transaction = new Transaction().add(SystemProgram.transfer({
+        fromPubkey: new PublicKey(params.from),
+        toPubkey: new PublicKey(params.to),
+        lamports: Number(params.amount)
+    }));
+    transaction.recentBlockhash = params.blockhash;
+    transaction.feePayer = new PublicKey(params.from);
+    return transaction;
+}
+//# sourceMappingURL=solana-transactions.js.map

package/dist/utils/solana-transactions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana-transactions.js","sourceRoot":"","sources":["../../src/utils/solana-transactions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,aAAa,EACb,WAAW,EACX,oBAAoB,EACrB,MAAM,iBAAiB,CAAA;AAExB,MAAM,UAAU,oBAAoB,CAAC,MAAmC;IACtE,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;IAClE,CAAC;IAED,MAAM,WAAW,GAAuC,IAAI,WAAW,EAAE,CAAC,GAAG,CAC3E,aAAa,CAAC,QAAQ,CAAC;QACrB,UAAU,EAAE,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC;QACtC,QAAQ,EAAE,IAAI,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;QAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;KAChC,CAAC,CACH,CAAA;IACD,WAAW,CAAC,eAAe,GAAG,MAAM,CAAC,SAAS,CAAA;IAC9C,WAAW,CAAC,QAAQ,GAAG,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACjD,OAAO,WAAW,CAAA;AACpB,CAAC"}

package/dist/wallet-connect-connector.d.ts

@@ -0,0 +1,17 @@
+import type { Network, Connector, ConnectorResult, SwitchNetworkResult, WalletConnectConfig, WalletConnectProvider, TransactionRequest, TransactionResult, NetworkRpcMap } from '@meshconnect/uwc-types';
+export declare class WalletConnectConnector implements Connector {
+    private walletConnectClient;
+    private connectionService;
+    private networkSwitchService;
+    private signatureService;
+    private transactionService;
+    private networkRpcMap;
+    constructor(config: WalletConnectConfig, networkRpcMap?: NetworkRpcMap);
+    connect(network: Network, provider?: WalletConnectProvider): Promise<ConnectorResult>;
+    getConnectionURI(): string;
+    disconnect(): Promise<void>;
+    switchNetwork(network: Network): Promise<SwitchNetworkResult>;
+    signMessage(message: string): Promise<string>;
+    sendTransaction(request: TransactionRequest): Promise<TransactionResult>;
+}
+//# sourceMappingURL=wallet-connect-connector.d.ts.map

package/dist/wallet-connect-connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-connect-connector.d.ts","sourceRoot":"","sources":["../src/wallet-connect-connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACd,MAAM,wBAAwB,CAAA;AAO/B,qBAAa,sBAAuB,YAAW,SAAS;IACtD,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,iBAAiB,CAAmB;IAC5C,OAAO,CAAC,oBAAoB,CAAsB;IAClD,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,kBAAkB,CAAoB;IAC9C,OAAO,CAAC,aAAa,CAAe;gBAExB,MAAM,EAAE,mBAAmB,EAAE,aAAa,GAAE,aAAkB;IAmBpE,OAAO,CACX,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,qBAAqB,GAC/B,OAAO,CAAC,eAAe,CAAC;IAU3B,gBAAgB,IAAI,MAAM;IAQpB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAI7D,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI7C,eAAe,CACnB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,iBAAiB,CAAC;CAG9B"}

package/dist/wallet-connect-connector.js

@@ -0,0 +1,47 @@
+import { WalletConnectClient } from './services/walletconnect-client';
+import { ConnectionService } from './services/connection-service';
+import { NetworkSwitchService } from './services/network-switch-service';
+import { SignatureService } from './services/signature-service';
+import { TransactionService } from './services/transaction-service';
+export class WalletConnectConnector {
+    walletConnectClient;
+    connectionService;
+    networkSwitchService;
+    signatureService;
+    transactionService;
+    networkRpcMap;
+    constructor(config, networkRpcMap = {}) {
+        this.walletConnectClient = new WalletConnectClient(config);
+        this.networkRpcMap = networkRpcMap;
+        this.connectionService = new ConnectionService(this.walletConnectClient);
+        this.networkSwitchService = new NetworkSwitchService(this.walletConnectClient, this.connectionService);
+        this.signatureService = new SignatureService(this.walletConnectClient, this.connectionService);
+        this.transactionService = new TransactionService(this.walletConnectClient, this.connectionService, this.networkRpcMap);
+    }
+    async connect(network, provider) {
+        if (!provider) {
+            throw new Error('WalletConnectProvider is required for WalletConnect connection');
+        }
+        return this.connectionService.connect(network, provider);
+    }
+    getConnectionURI() {
+        const uri = this.connectionService.getConnectionURI();
+        if (!uri) {
+            throw new Error('No connection URI available. Call connect() first.');
+        }
+        return uri;
+    }
+    async disconnect() {
+        return this.connectionService.disconnect();
+    }
+    async switchNetwork(network) {
+        return this.networkSwitchService.switchNetwork(network);
+    }
+    async signMessage(message) {
+        return this.signatureService.signMessage(message);
+    }
+    async sendTransaction(request) {
+        return this.transactionService.sendTransaction(request);
+    }
+}
+//# sourceMappingURL=wallet-connect-connector.js.map

package/dist/wallet-connect-connector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-connect-connector.js","sourceRoot":"","sources":["../src/wallet-connect-connector.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAA;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAEnE,MAAM,OAAO,sBAAsB;IACzB,mBAAmB,CAAqB;IACxC,iBAAiB,CAAmB;IACpC,oBAAoB,CAAsB;IAC1C,gBAAgB,CAAkB;IAClC,kBAAkB,CAAoB;IACtC,aAAa,CAAe;IAEpC,YAAY,MAA2B,EAAE,gBAA+B,EAAE;QACxE,IAAI,CAAC,mBAAmB,GAAG,IAAI,mBAAmB,CAAC,MAAM,CAAC,CAAA;QAC1D,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,iBAAiB,GAAG,IAAI,iBAAiB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAA;QACxE,IAAI,CAAC,oBAAoB,GAAG,IAAI,oBAAoB,CAClD,IAAI,CAAC,mBAAmB,EACxB,IAAI,CAAC,iBAAiB,CACvB,CAAA;QACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAC1C,IAAI,CAAC,mBAAmB,EACxB,IAAI,CAAC,iBAAiB,CACvB,CAAA;QACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,kBAAkB,CAC9C,IAAI,CAAC,mBAAmB,EACxB,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,aAAa,CACnB,CAAA;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CACX,OAAgB,EAChB,QAAgC;QAEhC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAA;QACH,CAAC;QAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;IAC1D,CAAC;IAED,gBAAgB;QACd,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAA;QACrD,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAA;QACvE,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,CAAA;IAC5C,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,OAAgB;QAClC,OAAO,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;IACzD,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAe;QAC/B,OAAO,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;IACnD,CAAC;IAED,KAAK,CAAC,eAAe,CACnB,OAA2B;QAE3B,OAAO,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;IACzD,CAAC;CACF"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@meshconnect/uwc-wallet-connect-connector",
+  "version": "0.2.0",
+  "description": "WalletConnect connector for Universal Wallet Connector",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@solana/web3.js": "^1.98.4",
+    "@walletconnect/sign-client": "^2.21.8",
+    "@walletconnect/types": "^2.21.8",
+    "@walletconnect/utils": "^2.21.8",
+    "bs58": "^6.0.0",
+    "buffer": "^6.0.3",
+    "ethers": "^6.15.0",
+    "@meshconnect/uwc-types": "0.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "type-check": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './wallet-connect-connector'

package/src/services/connection-service.ts

@@ -0,0 +1,304 @@
+import type { SessionTypes } from '@walletconnect/types'
+import type {
+  Network,
+  AvailableAddress,
+  ConnectorResult,
+  WalletConnectProvider,
+  Namespace
+} from '@meshconnect/uwc-types'
+import { WalletConnectClient } from './walletconnect-client'
+import { parseAccount, getNamespaceFromNetworkId } from '../utils/account-utils'
+import { parseError } from '../utils/error-utils'
+
+/**
+ * Service for handling WalletConnect connections
+ */
+export class ConnectionService {
+  private currentSession: SessionTypes.Struct | null = null
+  private connectionUri: string | null = null
+  private activeNetwork: Network | null = null
+  private activeAddress: string | null = null
+
+  constructor(private walletConnectClient: WalletConnectClient) {}
+
+  /**
+   * Connect to a wallet via WalletConnect
+   * This will store the URI and wait for approval
+   */
+  async connect(
+    network: Network,
+    provider: WalletConnectProvider
+  ): Promise<ConnectorResult> {
+    try {
+      const client = await this.walletConnectClient.getClient()
+
+      // Disconnect any existing sessions first
+      await this.walletConnectClient.disconnectAll()
+
+      // Build namespaces from the provider's supported network IDs
+      const optionalNamespaces = this.buildNamespacesFromProvider(provider)
+
+      // Initiate connection - this starts the connection process
+      const connectResult = await client.connect({
+        optionalNamespaces
+      })
+
+      if (!connectResult.uri) {
+        throw new Error('No connection URI generated')
+      }
+
+      // Store the URI immediately so it can be retrieved via getConnectionURI
+      this.connectionUri = connectResult.uri
+
+      // Start the approval process in the background
+      // The main thread will poll for the URI while this waits for approval
+      const approvalPromise = connectResult.approval()
+
+      try {
+        // Wait for approval (this resolves when user approves in wallet)
+        const session = await approvalPromise
+        this.currentSession = session
+        this.connectionUri = null // Clear URI after connection
+
+        // Extract addresses from session
+        const { address, availableAddresses } = this.extractAddresses(
+          session,
+          network,
+          provider
+        )
+
+        // Store the active network and address
+        this.activeNetwork = network
+        this.activeAddress = address
+
+        return {
+          networkId: network.id,
+          address,
+          availableAddresses
+        }
+      } catch (approvalError) {
+        this.connectionUri = null // Clear URI on error
+        throw approvalError
+      }
+    } catch (error) {
+      this.connectionUri = null // Clear URI on error
+      throw parseError(error)
+    }
+  }
+
+  /**
+   * Get the current connection URI
+   */
+  getConnectionURI(): string | null {
+    return this.connectionUri
+  }
+
+  /**
+   * Build WalletConnect namespaces from provider's supported network IDs
+   */
+  private buildNamespacesFromProvider(provider: WalletConnectProvider): Record<
+    string,
+    {
+      chains: string[]
+      methods: string[]
+      events: string[]
+    }
+  > {
+    const namespaces: Record<
+      string,
+      {
+        chains: string[]
+        methods: string[]
+        events: string[]
+      }
+    > = {}
+
+    // Group networks by namespace
+    const namespaceGroups: Record<Namespace, string[]> = {} as Record<
+      Namespace,
+      string[]
+    >
+
+    provider.supportedNetworkIds.forEach(networkId => {
+      const namespace = getNamespaceFromNetworkId(networkId)
+      if (!namespaceGroups[namespace]) {
+        namespaceGroups[namespace] = []
+      }
+      namespaceGroups[namespace]!.push(networkId)
+    })
+
+    // Build namespaces for each group
+    Object.entries(namespaceGroups).forEach(([namespace, chains]) => {
+      switch (namespace) {
+        case 'eip155':
+          namespaces['eip155'] = {
+            chains,
+            methods: [
+              'personal_sign',
+              'eth_sign',
+              'eth_signTypedData',
+              'eth_signTypedData_v4',
+              'eth_sendTransaction',
+              'eth_sendRawTransaction',
+              'eth_accounts',
+              'eth_requestAccounts',
+              'wallet_switchEthereumChain',
+              'wallet_addEthereumChain'
+            ],
+            events: ['chainChanged', 'accountsChanged']
+          }
+          break
+
+        case 'solana':
+          namespaces['solana'] = {
+            chains,
+            methods: [
+              'solana_signMessage',
+              'solana_signTransaction',
+              'solana_signAndSendTransaction',
+              'solana_getAccounts',
+              'solana_requestAccounts'
+            ],
+            events: []
+          }
+          break
+
+        case 'bip122':
+          namespaces['bip122'] = {
+            chains,
+            methods: [
+              'sendTransfer',
+              'getAccountAddresses',
+              'signPsbt',
+              'signMessage'
+            ],
+            events: ['bip122_addressesChanged']
+          }
+          break
+
+        case 'tron':
+          namespaces['tron'] = {
+            chains,
+            methods: ['tron_signTransaction', 'tron_signMessage'],
+            events: []
+          }
+          break
+
+        default:
+          // For unknown namespaces, include basic methods
+          namespaces[namespace] = {
+            chains,
+            methods: [],
+            events: []
+          }
+      }
+    })
+
+    return namespaces
+  }
+
+  /**
+   * Extract addresses from a WalletConnect session
+   */
+  private extractAddresses(
+    session: SessionTypes.Struct,
+    network: Network,
+    provider: WalletConnectProvider
+  ): {
+    address: string
+    availableAddresses: AvailableAddress[]
+  } {
+    const availableAddresses: AvailableAddress[] = []
+    let primaryAddress = ''
+
+    // Extract addresses from all namespaces
+    Object.entries(session.namespaces).forEach(([, data]) => {
+      data.accounts.forEach((account: string) => {
+        try {
+          const { networkId, address } = parseAccount(account)
+
+          // Only include addresses for networks that are supported by the provider
+          if (provider.supportedNetworkIds.includes(networkId)) {
+            availableAddresses.push({
+              address,
+              networkId
+            })
+
+            // Set the primary address based on the requested network
+            if (networkId === network.id && !primaryAddress) {
+              primaryAddress = address
+            }
+          }
+        } catch {
+          // Skip invalid account formats
+        }
+      })
+    })
+
+    // If no address for the specific network, use the first available
+    if (!primaryAddress && availableAddresses.length > 0) {
+      primaryAddress = availableAddresses[0]?.address || ''
+    }
+
+    if (!primaryAddress) {
+      throw new Error('No addresses found in session')
+    }
+
+    return { address: primaryAddress, availableAddresses }
+  }
+
+  /**
+   * Get current session
+   */
+  getSession(): SessionTypes.Struct | null {
+    return this.currentSession
+  }
+
+  /**
+   * Set session (for restoration)
+   */
+  setSession(session: SessionTypes.Struct): void {
+    this.currentSession = session
+  }
+
+  /**
+   * Get active network
+   */
+  getActiveNetwork(): Network | null {
+    return this.activeNetwork
+  }
+
+  /**
+   * Set active network (for network switching)
+   */
+  setActiveNetwork(network: Network): void {
+    this.activeNetwork = network
+  }
+
+  /**
+   * Get active address
+   */
+  getActiveAddress(): string | null {
+    return this.activeAddress
+  }
+
+  /**
+   * Set active address (for network/address switching)
+   */
+  setActiveAddress(address: string): void {
+    this.activeAddress = address
+  }
+
+  /**
+   * Disconnect current session
+   */
+  async disconnect(): Promise<void> {
+    if (this.currentSession) {
+      await this.walletConnectClient.disconnect(this.currentSession.topic)
+      this.currentSession = null
+    }
+    this.connectionUri = null
+    this.activeNetwork = null
+    this.activeAddress = null
+  }
+}

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

@@ -0,0 +1,83 @@
+import type { Network, SwitchNetworkResult } from '@meshconnect/uwc-types'
+import { WalletConnectClient } from './walletconnect-client'
+import { ConnectionService } from './connection-service'
+import { parseAccount } from '../utils/account-utils'
+import { parseError } from '../utils/error-utils'
+
+/**
+ * Service for handling network switching in WalletConnect
+ */
+export class NetworkSwitchService {
+  constructor(
+    private walletConnectClient: WalletConnectClient,
+    private connectionService: ConnectionService
+  ) {}
+
+  /**
+   * Switch to a different network
+   */
+  async switchNetwork(network: Network): Promise<SwitchNetworkResult> {
+    try {
+      const session = this.connectionService.getSession()
+      if (!session) {
+        throw new Error('No active session. Please connect first.')
+      }
+
+      const client = await this.walletConnectClient.getClient()
+
+      // Check if the requested network is available in the session
+      const networkChain = network.id
+      const namespace = network.namespace
+
+      if (!session.namespaces[namespace]?.chains?.includes(networkChain)) {
+        throw new Error(
+          `Network ${networkChain} is not available in the current session`
+        )
+      }
+
+      // For WalletConnect, we can't directly switch networks
+      // The wallet controls the active network
+      // We can only request methods on specific chains
+      // Return the current address for the requested network
+
+      const accounts = session.namespaces[namespace]?.accounts || []
+      const matchingAccount = accounts.find(account =>
+        account.startsWith(networkChain)
+      )
+
+      if (!matchingAccount) {
+        throw new Error(`No account found for network ${networkChain}`)
+      }
+
+      // Extract address from account string
+      const { address } = parseAccount(matchingAccount)
+
+      // Update the active network and address in the connection service
+      this.connectionService.setActiveNetwork(network)
+      this.connectionService.setActiveAddress(address)
+
+      // Emit a chainChanged event if switching within the same namespace
+      if (namespace === 'eip155') {
+        try {
+          await client.emit({
+            topic: session.topic,
+            event: {
+              name: 'chainChanged',
+              data: networkChain
+            },
+            chainId: networkChain
+          })
+        } catch {
+          // Some wallets may not support this event
+        }
+      }
+
+      return {
+        networkId: network.id,
+        address
+      }
+    } catch (error) {
+      throw parseError(error)
+    }
+  }
+}