@marigoldlabs/web3-tester 0.4.1 → 0.4.2

package/dist/walletconnect.js

@@ -1,5 +1,13 @@
 import { toHex } from 'viem';
 import { serializeRpcError } from './errors.js';
+import { createWalletPersona, walletConnectMetadataForPersona, } from './wallet-personas.js';
+const removeWalletConnectListener = (client, event, handler) => {
+    if (client.off) {
+        client.off(event, handler);
+        return;
+    }
+    client.removeListener?.(event, handler);
+};
 export const DEFAULT_WALLETCONNECT_METHODS = [
     'eth_sendTransaction',
     'eth_sendRawTransaction',
@@ -16,11 +24,39 @@ export const DEFAULT_WALLETCONNECT_METHODS = [
     'wallet_getPermissions',
     'wallet_requestPermissions',
     'wallet_watchAsset',
+    'wallet_getCapabilities',
+    'wallet_sendCalls',
+    'wallet_getCallsStatus',
+    'wallet_showCallsStatus',
+];
+export const DEFAULT_WALLETCONNECT_COINBASE_METHODS = [
+    'wallet_connect',
+    'wallet_addSubAccount',
+    'wallet_getSubAccounts',
+    'coinbase_fetchPermissions',
+    'coinbase_fetchPermission',
 ];
 const DEFAULT_EVENTS = ['chainChanged', 'accountsChanged'];
+export const DEFAULT_WALLETCONNECT_SOLANA_METHODS = [
+    'solana_getAccounts',
+    'solana_requestAccounts',
+    'solana_signIn',
+    'solana_signAllTransactions',
+    'solana_signAndSendAllTransactions',
+    'solana_signAndSendTransaction',
+    'solana_signMessage',
+    'solana_signTransaction',
+];
+const DEFAULT_SOLANA_EVENTS = ['accountsChanged'];
+const DEFAULT_SOLANA_CHAINS = [
+    'solana:mainnet',
+    'solana:devnet',
+    'solana:testnet',
+];
 // Injectable so the missing-optional-peer hint is hermetically testable
 // (the peers are devDependencies here, so they always resolve in-repo).
 let loadModule = (specifier) => import(specifier);
+let walletConnectStoragePrefixCounter = 0;
 /** @internal Test hook: stub the dynamic importer; call with no args to restore. */
 export const __setWalletConnectModuleLoader = (loader) => {
     loadModule = loader ?? ((specifier) => import(specifier));
@@ -29,7 +65,206 @@ const parseCaipChainId = (caip) => {
     const match = typeof caip === 'string' ? /^eip155:(\d+)$/.exec(caip) : null;
     return match ? toHex(BigInt(match[1])) : undefined;
 };
+const parseSolanaCaipChainId = (caip) => typeof caip === 'string' && /^solana:[a-z0-9-]+$/i.test(caip) ? caip : undefined;
 const toCaipChainId = (chainId) => `eip155:${Number(BigInt(chainId))}`;
+const isAddressString = (value) => typeof value === 'string' && /^0x[0-9a-fA-F]{40}$/.test(value);
+const eip155AccountsFor = (chains, accounts) => chains.flatMap((chainId) => accounts.map((account) => `${chainId}:${account}`));
+const arraysEqual = (left = [], right = []) => left.length === right.length && left.every((value, index) => value === right[index]);
+const bytesFrom = (input) => {
+    if (input instanceof Uint8Array)
+        return [...input];
+    if (input instanceof ArrayBuffer)
+        return [...new Uint8Array(input)];
+    if (ArrayBuffer.isView(input)) {
+        return [...new Uint8Array(input.buffer, input.byteOffset, input.byteLength)];
+    }
+    if (Array.isArray(input))
+        return input.map((value) => Number(value) & 255);
+    if (typeof input === 'string')
+        return [...new TextEncoder().encode(input)];
+    return [...new TextEncoder().encode(JSON.stringify(input ?? null))];
+};
+const deterministicSignature = (publicKey, payload) => {
+    const seed = [...new TextEncoder().encode(publicKey), ...bytesFrom(payload)];
+    const signature = new Uint8Array(64);
+    for (let index = 0; index < signature.length; index += 1) {
+        const a = seed[index % seed.length] ?? 0;
+        const b = seed[(index * 7 + 13) % seed.length] ?? 0;
+        signature[index] = (a + b + index * 17) & 255;
+    }
+    return signature;
+};
+const base58Encode = (input) => {
+    const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    const digits = [0];
+    for (const byte of input) {
+        let carry = byte;
+        for (let index = 0; index < digits.length; index += 1) {
+            const next = digits[index] * 256 + carry;
+            digits[index] = next % 58;
+            carry = Math.floor(next / 58);
+        }
+        while (carry > 0) {
+            digits.push(carry % 58);
+            carry = Math.floor(carry / 58);
+        }
+    }
+    for (const byte of input) {
+        if (byte !== 0)
+            break;
+        digits.push(0);
+    }
+    return digits
+        .reverse()
+        .map((digit) => alphabet[digit])
+        .join('');
+};
+const signatureFor = (publicKey, payload) => base58Encode(deterministicSignature(publicKey, payload));
+const resolveSolanaOptions = (option, persona) => {
+    if (option === false) {
+        return undefined;
+    }
+    const input = typeof option === 'object' ? option : {};
+    const personaSolana = persona?.solana;
+    if (!personaSolana && option !== true && option === undefined) {
+        return undefined;
+    }
+    return {
+        chains: input.chains ?? personaSolana?.chains ?? DEFAULT_SOLANA_CHAINS,
+        publicKey: input.publicKey ??
+            personaSolana?.publicKey ??
+            '26qv4GCcx98RihuK3c4T6ozB3J7L6VwCuFVc7Ta2A3Uo',
+        methods: input.methods ?? DEFAULT_WALLETCONNECT_SOLANA_METHODS,
+        events: input.events ?? DEFAULT_SOLANA_EVENTS,
+    };
+};
+const rpcError = (code, message) => {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+};
+const normalizeObjectParams = (params) => {
+    const candidate = Array.isArray(params) ? params[0] : params;
+    return candidate && typeof candidate === 'object' ? candidate : {};
+};
+const normalizeJsonRpcParams = (params) => {
+    if (params === undefined || Array.isArray(params))
+        return params;
+    if (params && typeof params === 'object')
+        return params;
+    return [params];
+};
+const assertSolanaPubkey = (params, publicKey) => {
+    const requested = params.pubkey;
+    if (requested !== undefined && requested !== publicKey) {
+        throw rpcError(4100, `The requested Solana account ${String(requested)} is not authorized.`);
+    }
+};
+const solanaAccountsResult = (solana) => [
+    { pubkey: solana.publicKey },
+];
+const buildSolanaSignInMessage = (publicKey, input = {}) => {
+    const address = input.address ?? publicKey;
+    const domain = input.domain ?? 'localhost';
+    const lines = [
+        `${domain} wants you to sign in with your Solana account:`,
+        String(address),
+    ];
+    if (input.statement !== undefined) {
+        lines.push('', String(input.statement));
+    }
+    const fields = [
+        ['URI', input.uri],
+        ['Version', input.version],
+        ['Chain ID', input.chainId],
+        ['Nonce', input.nonce],
+        ['Issued At', input.issuedAt],
+        ['Expiration Time', input.expirationTime],
+        ['Not Before', input.notBefore],
+        ['Request ID', input.requestId],
+    ];
+    for (const [label, value] of fields) {
+        if (value !== undefined) {
+            lines.push(`${label}: ${String(value)}`);
+        }
+    }
+    if (Array.isArray(input.resources) && input.resources.length > 0) {
+        lines.push('Resources:');
+        for (const resource of input.resources) {
+            lines.push(`- ${String(resource)}`);
+        }
+    }
+    return new TextEncoder().encode(lines.join('\n'));
+};
+const handleSolanaSessionRequest = async (wallet, solana, event, context) => {
+    const method = event.params.request.method;
+    if (!solana.methods.includes(method)) {
+        throw rpcError(4200, `The mock wallet does not support the method "${method}".`);
+    }
+    const params = normalizeObjectParams(event.params.request.params);
+    switch (method) {
+        case 'solana_getAccounts': {
+            const accounts = (await wallet.handleExternalRequest({ method: 'eth_accounts', params: [] }, context));
+            return accounts && accounts.length > 0 ? solanaAccountsResult(solana) : [];
+        }
+        case 'solana_requestAccounts':
+            await wallet.handleExternalRequest({ method, params: [params] }, context);
+            return solanaAccountsResult(solana);
+        case 'solana_signIn': {
+            const input = normalizeObjectParams(params.input ?? params);
+            if (input.address !== undefined && input.address !== solana.publicKey) {
+                throw rpcError(4100, `The requested Solana account ${String(input.address)} is not authorized.`);
+            }
+            const signedMessage = buildSolanaSignInMessage(solana.publicKey, input);
+            await wallet.handleExternalRequest({
+                method,
+                params: [{ input, publicKey: solana.publicKey, message: [...signedMessage] }],
+            }, context);
+            return {
+                address: input.address ?? solana.publicKey,
+                publicKey: solana.publicKey,
+                signedMessage: [...signedMessage],
+                signature: signatureFor(solana.publicKey, signedMessage),
+                signatureType: 'ed25519',
+            };
+        }
+        case 'solana_signMessage':
+            assertSolanaPubkey(params, solana.publicKey);
+            await wallet.handleExternalRequest({ method, params: [params] }, context);
+            return {
+                signature: signatureFor(solana.publicKey, params.message ?? ''),
+            };
+        case 'solana_signTransaction':
+            await wallet.handleExternalRequest({ method, params: [params] }, context);
+            return {
+                signature: signatureFor(solana.publicKey, params.transaction ?? params),
+                ...(typeof params.transaction === 'string' ? { transaction: params.transaction } : {}),
+            };
+        case 'solana_signAllTransactions': {
+            await wallet.handleExternalRequest({ method, params: [params] }, context);
+            const transactions = Array.isArray(params.transactions) ? params.transactions : [];
+            return {
+                transactions,
+                signatures: transactions.map((transaction) => signatureFor(solana.publicKey, transaction)),
+            };
+        }
+        case 'solana_signAndSendAllTransactions': {
+            await wallet.handleExternalRequest({ method, params: [params] }, context);
+            const transactions = Array.isArray(params.transactions) ? params.transactions : [];
+            return {
+                publicKey: solana.publicKey,
+                signatures: transactions.map((transaction) => signatureFor(solana.publicKey, transaction)),
+            };
+        }
+        case 'solana_signAndSendTransaction':
+            await wallet.handleExternalRequest({ method, params: [params] }, context);
+            return {
+                signature: signatureFor(solana.publicKey, params.transaction ?? params),
+            };
+        default:
+            throw rpcError(4200, `The mock wallet does not support the method "${method}".`);
+    }
+};
 /**
  * The session_request loop, exported for hermetic tests: validates the CAIP
  * chain against the approved set, switches the wallet when an approved
@@ -42,8 +277,26 @@ export const createSessionRequestHandler = (wallet, config, respond) => {
     return async (event) => {
         const { id, topic, params, verifyContext } = event;
         try {
+            const context = config.enforceOrigins
+                ? { origin: verifyContext?.verified?.origin }
+                : { bypassOriginCheck: true };
+            const solanaChain = parseSolanaCaipChainId(params.chainId);
+            if (solanaChain) {
+                if (!config.solana || !config.solana.chains.includes(solanaChain)) {
+                    await respond(topic, {
+                        id,
+                        jsonrpc: '2.0',
+                        error: { code: 5100, message: 'Requested chain is not approved for this session.' },
+                    });
+                    return;
+                }
+                const result = await handleSolanaSessionRequest(wallet, config.solana, event, context);
+                await respond(topic, { id, jsonrpc: '2.0', result });
+                return;
+            }
             const chainId = parseCaipChainId(params.chainId);
-            if (!chainId || !config.chains.includes(chainId)) {
+            const approvedChains = config.getChains?.() ?? config.chains;
+            if (!chainId || !approvedChains.includes(chainId)) {
                 await respond(topic, {
                     id,
                     jsonrpc: '2.0',
@@ -54,9 +307,7 @@ export const createSessionRequestHandler = (wallet, config, respond) => {
             if (chainId !== wallet.currentChainId) {
                 await wallet.switchNetwork(chainId);
             }
-            const result = await wallet.handleExternalRequest({ method: params.request.method, params: params.request.params }, config.enforceOrigins
-                ? { origin: verifyContext?.verified?.origin }
-                : { bypassOriginCheck: true });
+            const result = await wallet.handleExternalRequest({ method: params.request.method, params: normalizeJsonRpcParams(params.request.params) }, context);
             await respond(topic, { id, jsonrpc: '2.0', result });
         }
         catch (error) {
@@ -73,32 +324,140 @@ export const createSessionRequestHandler = (wallet, config, respond) => {
         }
     };
 };
+export const createSessionAuthenticateHandler = (wallet, config, auth) => {
+    return async (event) => {
+        const { id, params, verifyContext } = event;
+        const context = config.enforceOrigins
+            ? { origin: verifyContext?.verified?.origin }
+            : { bypassOriginCheck: true };
+        const requestedChains = Array.isArray(params.authPayload.chains)
+            ? params.authPayload.chains.map(parseCaipChainId)
+            : [];
+        const approvedChains = config.getChains?.() ?? config.chains;
+        const unsupported = requestedChains.some((chainId) => !chainId || !approvedChains.includes(chainId));
+        if (requestedChains.length === 0 || unsupported) {
+            await auth.reject(id, auth.getSdkError('UNSUPPORTED_CHAINS')).catch(() => undefined);
+            return;
+        }
+        try {
+            const proposalPayload = {
+                origin: verifyContext?.verified?.origin,
+                requester: params.requester?.metadata,
+                authPayload: params.authPayload,
+            };
+            const accounts = (await wallet.handleExternalRequest({ method: 'eth_requestAccounts', params: [proposalPayload] }, context));
+            const auths = [];
+            for (const chainId of requestedChains) {
+                const caip = toCaipChainId(chainId);
+                for (const account of accounts) {
+                    const iss = `did:pkh:${caip}:${account}`;
+                    const message = auth.formatAuthMessage({ request: params.authPayload, iss });
+                    const signature = (await wallet.handleExternalRequest({ method: 'personal_sign', params: [toHex(message), account] }, context));
+                    auths.push(auth.buildAuthObject(params.authPayload, { t: 'eip191', s: signature, m: message }, iss));
+                }
+            }
+            const result = await auth.approve(id, auths);
+            if (result.session) {
+                auth.onSession?.({
+                    topic: result.session.topic,
+                    namespaces: result.session.namespaces ?? {},
+                    peerMetadata: result.session.peer?.metadata ??
+                        params.requester?.metadata ??
+                        { name: '', description: '', url: '', icons: [] },
+                });
+            }
+        }
+        catch {
+            await auth.reject(id, auth.getSdkError('USER_REJECTED')).catch(() => undefined);
+        }
+    };
+};
+const DEFAULT_URI_SELECTORS = ['wui-qr-code', '[uri^="wc:"]', '[data-uri^="wc:"]', '[href^="wc:"]'];
+const DEFAULT_URI_ATTRIBUTES = ['uri', 'data-uri', 'href', 'value'];
+const DEFAULT_TEXT_SELECTORS = ['textarea', 'input', 'code', 'pre', '[data-wc-uri]'];
+const DEFAULT_COPY_BUTTON_SELECTORS = ['[data-testid="copy-wc2-uri"]'];
+const URI_PROBE_MS = 250;
+const uniq = (values) => [
+    ...new Set(values.filter((value) => Boolean(value))),
+];
+const extractWalletConnectUri = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    const decoded = /wc%3a/i.test(trimmed)
+        ? decodeURIComponent(trimmed)
+        : trimmed;
+    const match = /wc:[^\s"'<>`]+/.exec(decoded);
+    return match?.[0];
+};
+const readLocatorText = async (locator) => {
+    return locator
+        .first()
+        .evaluate((element) => {
+        if (element instanceof HTMLInputElement ||
+            element instanceof HTMLTextAreaElement ||
+            element instanceof HTMLSelectElement) {
+            return element.value;
+        }
+        return element.textContent ?? '';
+    }, undefined, { timeout: URI_PROBE_MS })
+        .catch(() => undefined);
+};
+const readClipboard = async (page) => page
+    .evaluate(() => navigator.clipboard?.readText?.())
+    .catch(() => undefined);
 /**
- * Polls the AppKit/W3M modal for the pairing URI: Playwright CSS locators
- * pierce the shadow DOM, and AppKit's w3m-connecting-wc-qrcode renders
- * `<wui-qr-code uri=...>` as a real DOM attribute (the same contract
- * Reown's own laboratory tests read). For non-AppKit modals pass a
- * `selector` or use the connect() `getUri` hook.
+ * Polls common WalletConnect QR/modal surfaces for a pairing URI. Defaults
+ * keep the AppKit/W3M `wui-qr-code[uri]` contract, then fall back to generic
+ * URI attributes, text/value-bearing elements, and AppKit's copy button.
+ * For unusual modals pass selectors/textSelectors/copyButtonSelector or use
+ * the connect() getUri hook.
  */
 export async function getWalletConnectUri(page, options = {}) {
     const timeoutMs = options.timeoutMs ?? 15_000;
-    const selector = options.selector ?? 'wui-qr-code';
+    const selectors = uniq([
+        options.selector,
+        ...(options.selectors ?? []),
+        ...DEFAULT_URI_SELECTORS,
+    ]);
+    const attributes = options.attributes ?? DEFAULT_URI_ATTRIBUTES;
+    const textSelectors = uniq([...(options.textSelectors ?? []), ...DEFAULT_TEXT_SELECTORS]);
+    const copyButtonSelectors = uniq([
+        options.copyButtonSelector,
+        ...(options.copyButtonSelectors ?? []),
+        ...DEFAULT_COPY_BUTTON_SELECTORS,
+    ]);
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        // Bounded per attempt: getAttribute would otherwise auto-wait for the
-        // element with Playwright's default timeout.
-        const uri = await page
-            .locator(selector)
-            .first()
-            .getAttribute('uri', { timeout: 250 })
-            .catch(() => null);
-        if (uri?.startsWith('wc:')) {
-            return uri;
+        for (const selector of selectors) {
+            const locator = page.locator(selector).first();
+            for (const attribute of attributes) {
+                const uri = extractWalletConnectUri(await locator.getAttribute(attribute, { timeout: URI_PROBE_MS }).catch(() => null));
+                if (uri)
+                    return uri;
+            }
+            const uri = extractWalletConnectUri(await readLocatorText(locator));
+            if (uri)
+                return uri;
+        }
+        for (const selector of textSelectors) {
+            const uri = extractWalletConnectUri(await readLocatorText(page.locator(selector)));
+            if (uri)
+                return uri;
+        }
+        for (const selector of copyButtonSelectors) {
+            const clicked = await page.locator(selector).first().click({ timeout: URI_PROBE_MS }).then(() => true, () => false);
+            if (!clicked)
+                continue;
+            const uri = extractWalletConnectUri(await readClipboard(page));
+            if (uri)
+                return uri;
         }
         await new Promise((resolve) => setTimeout(resolve, 100));
     }
-    throw new Error(`Timed out after ${timeoutMs}ms waiting for a wc: pairing URI on "${selector}". ` +
-        'For non-AppKit modals pass { selector } or supply a getUri(page) hook to connect().');
+    throw new Error(`Timed out after ${timeoutMs}ms waiting for a wc: pairing URI. ` +
+        `Probed selectors: ${[...selectors, ...textSelectors].join(', ')}. ` +
+        'For unusual modals pass selector/selectors/textSelectors/copyButtonSelector or supply a getUri(page) hook to connect().');
 }
 export class WalletConnectWallet {
     /** Underlying SignClient — escape hatch for protocol-level access. */
@@ -106,11 +465,14 @@ export class WalletConnectWallet {
     wallet;
     utils;
     chains;
+    evm;
     methods;
     events;
+    solana;
     enforceOrigins;
     sessionList = [];
     requestHandler;
+    authHandler;
     deleteHandler;
     unsubscribeProviderEvents;
     closed = false;
@@ -118,16 +480,40 @@ export class WalletConnectWallet {
         this.client = client;
         this.utils = utils;
         this.wallet = options.wallet;
+        const persona = options.persona ? createWalletPersona(options.persona) : undefined;
+        this.evm = options.evm ?? persona?.evm !== false;
         this.chains = (options.chains ?? [options.wallet.currentChainId]).map((chainId) => toHex(typeof chainId === 'number' ? chainId : BigInt(chainId)));
-        this.methods = options.methods ?? DEFAULT_WALLETCONNECT_METHODS;
+        this.methods =
+            options.methods ??
+                (persona?.flags?.isCoinbaseWallet === true
+                    ? [...DEFAULT_WALLETCONNECT_METHODS, ...DEFAULT_WALLETCONNECT_COINBASE_METHODS]
+                    : DEFAULT_WALLETCONNECT_METHODS);
         this.events = options.events ?? DEFAULT_EVENTS;
+        this.solana = resolveSolanaOptions(options.solana, persona);
         this.enforceOrigins = options.enforceOrigins ?? true;
-        // INVARIANT: never register a 'session_authenticate' listener. With zero
-        // listeners, sign-client routes One-Click Auth (SIWE) dapps through the
-        // wc_sessionPropose fallback — a plain session plus personal_sign —
-        // which this wallet handles. Subscribing would suppress that fallback.
-        this.requestHandler = createSessionRequestHandler(this.wallet, { chains: this.chains, enforceOrigins: this.enforceOrigins }, (topic, response) => this.client.respond({ topic, response }));
+        this.requestHandler = createSessionRequestHandler(this.wallet, {
+            chains: this.chains,
+            getChains: () => this.chains,
+            enforceOrigins: this.enforceOrigins,
+            solana: this.solana,
+        }, (topic, response) => this.client.respond({ topic, response }));
         client.on('session_request', this.requestHandler);
+        // One-Click Auth / SIWE uses a separate WC event and suppresses
+        // sign-client's plain session_proposal fallback once a listener exists.
+        // Keep the fallback available through sessionAuthenticate: false.
+        if (options.sessionAuthenticate !== false && this.evm) {
+            this.authHandler = createSessionAuthenticateHandler(this.wallet, { chains: this.chains, getChains: () => this.chains, enforceOrigins: this.enforceOrigins }, {
+                approve: (id, auths) => this.client.approveSessionAuthenticate({ id, auths }),
+                buildAuthObject: (requestPayload, signature, iss) => this.utils.buildAuthObject(requestPayload, signature, iss),
+                formatAuthMessage: (args) => this.client.formatAuthMessage(args),
+                getSdkError: (code) => this.utils.getSdkError(code),
+                onSession: (session) => {
+                    this.sessionList.push(session);
+                },
+                reject: (id, reason) => this.client.rejectSessionAuthenticate({ id, reason }),
+            });
+            client.on('session_authenticate', this.authHandler);
+        }
         this.deleteHandler = ({ topic }) => {
             const index = this.sessionList.findIndex((session) => session.topic === topic);
             if (index !== -1) {
@@ -160,11 +546,16 @@ export class WalletConnectWallet {
         const client = await SignClient.init({
             projectId: options.projectId,
             ...(options.relayUrl ? { relayUrl: options.relayUrl } : {}),
+            customStoragePrefix: options.customStoragePrefix ??
+                `web3-tester-wallet-${walletConnectStoragePrefixCounter++}`,
             metadata: {
                 name: 'web3-tester Wallet',
                 description: 'Headless WalletConnect wallet for E2E tests',
                 url: 'https://github.com/AndyMarigoldLabs/web3-tester',
                 icons: [],
+                ...(options.persona
+                    ? walletConnectMetadataForPersona(createWalletPersona(options.persona))
+                    : {}),
                 ...options.metadata,
             },
             // A request parked by holdNextRequest must not starve delivery of
@@ -190,7 +581,7 @@ export class WalletConnectWallet {
         const proposal = await new Promise((resolve, reject) => {
             const cleanup = () => {
                 clearTimeout(timer);
-                (this.client.off ?? this.client.removeListener)?.call(this.client, 'session_proposal', handler);
+                removeWalletConnectListener(this.client, 'session_proposal', handler);
             };
             const timer = setTimeout(() => {
                 cleanup();
@@ -213,19 +604,21 @@ export class WalletConnectWallet {
         // simulateRejection, and holds all apply with zero new machinery.
         let accounts;
         try {
-            accounts = (await this.wallet.handleExternalRequest({
-                method: 'eth_requestAccounts',
-                params: [
-                    {
-                        origin: proposal.verifyContext?.verified?.origin,
-                        proposer: proposal.params?.proposer?.metadata,
-                        requiredNamespaces: proposal.params?.requiredNamespaces,
-                        optionalNamespaces: proposal.params?.optionalNamespaces,
-                    },
-                ],
-            }, this.enforceOrigins
+            const context = this.enforceOrigins
                 ? { origin: proposal.verifyContext?.verified?.origin }
-                : { bypassOriginCheck: true }));
+                : { bypassOriginCheck: true };
+            const proposalPayload = {
+                origin: proposal.verifyContext?.verified?.origin,
+                proposer: proposal.params?.proposer?.metadata,
+                requiredNamespaces: proposal.params?.requiredNamespaces,
+                optionalNamespaces: proposal.params?.optionalNamespaces,
+            };
+            accounts = this.evm
+                ? (await this.wallet.handleExternalRequest({ method: 'eth_requestAccounts', params: [proposalPayload] }, context))
+                : [];
+            if (!this.evm && this.solana) {
+                await this.wallet.handleExternalRequest({ method: 'solana_requestAccounts', params: [proposalPayload] }, context);
+            }
         }
         catch (error) {
             await this.client
@@ -235,16 +628,29 @@ export class WalletConnectWallet {
         }
         let namespaces;
         try {
+            const supportedNamespaces = {};
+            if (this.evm) {
+                supportedNamespaces.eip155 = {
+                    chains: this.chains.map(toCaipChainId),
+                    methods: [...this.methods],
+                    events: [...this.events],
+                    accounts: this.chains.flatMap((chainId) => accounts.map((account) => `${toCaipChainId(chainId)}:${account}`)),
+                };
+            }
+            if (this.solana) {
+                supportedNamespaces.solana = {
+                    chains: [...this.solana.chains],
+                    methods: [...this.solana.methods],
+                    events: [...this.solana.events],
+                    accounts: this.solana.chains.map((chain) => `${chain}:${this.solana.publicKey}`),
+                };
+            }
+            if (Object.keys(supportedNamespaces).length === 0) {
+                throw new Error('No WalletConnect namespaces are enabled.');
+            }
             namespaces = this.utils.buildApprovedNamespaces({
                 proposal: proposal.params,
-                supportedNamespaces: {
-                    eip155: {
-                        chains: this.chains.map(toCaipChainId),
-                        methods: [...this.methods],
-                        events: [...this.events],
-                        accounts: this.chains.flatMap((chainId) => accounts.map((account) => `${toCaipChainId(chainId)}:${account}`)),
-                    },
-                },
+                supportedNamespaces,
             });
         }
         catch (error) {
@@ -295,8 +701,11 @@ export class WalletConnectWallet {
             new Promise((resolve) => setTimeout(resolve, 5_000)),
         ]).catch(() => undefined);
         this.unsubscribeProviderEvents();
-        (this.client.off ?? this.client.removeListener)?.call(this.client, 'session_request', this.requestHandler);
-        (this.client.off ?? this.client.removeListener)?.call(this.client, 'session_delete', this.deleteHandler);
+        removeWalletConnectListener(this.client, 'session_request', this.requestHandler);
+        removeWalletConnectListener(this.client, 'session_delete', this.deleteHandler);
+        if (this.authHandler) {
+            removeWalletConnectListener(this.client, 'session_authenticate', this.authHandler);
+        }
         await this.client.core?.relayer?.transportClose?.().catch(() => undefined);
         this.client.core?.heartbeat?.stop?.();
     }
@@ -307,28 +716,30 @@ export class WalletConnectWallet {
         for (const session of [...this.sessionList]) {
             try {
                 if (event === 'chainChanged') {
+                    const namespaces = session.namespaces;
+                    const eip155 = namespaces.eip155;
+                    if (!eip155)
+                        continue;
                     const chainId = payload;
+                    const caip = toCaipChainId(chainId);
                     if (!this.chains.includes(chainId)) {
-                        // Extend the session namespace first (MetaMask-mobile behavior).
                         this.chains = [...this.chains, chainId];
-                        const namespaces = session.namespaces;
-                        const eip155 = namespaces.eip155;
-                        if (eip155) {
-                            const caip = toCaipChainId(chainId);
-                            const extended = {
-                                ...namespaces,
-                                eip155: {
-                                    ...eip155,
-                                    chains: [...(eip155.chains ?? []), caip],
-                                    accounts: [
-                                        ...(eip155.accounts ?? []),
-                                        ...this.wallet.currentAccounts.map((account) => `${caip}:${account}`),
-                                    ],
-                                },
-                            };
-                            await this.client.update({ topic: session.topic, namespaces: extended });
-                            session.namespaces = extended;
-                        }
+                    }
+                    if (!(eip155.chains ?? []).includes(caip)) {
+                        // Extend the session namespace first (MetaMask-mobile behavior).
+                        const extended = {
+                            ...namespaces,
+                            eip155: {
+                                ...eip155,
+                                chains: uniq([...(eip155.chains ?? []), caip]),
+                                accounts: uniq([
+                                    ...(eip155.accounts ?? []),
+                                    ...this.wallet.currentAccounts.map((account) => `${caip}:${account}`),
+                                ]),
+                            },
+                        };
+                        await this.client.update({ topic: session.topic, namespaces: extended });
+                        session.namespaces = extended;
                     }
                     await this.client.emit({
                         topic: session.topic,
@@ -337,11 +748,40 @@ export class WalletConnectWallet {
                     });
                 }
                 else if (event === 'accountsChanged') {
-                    await this.client.emit({
-                        topic: session.topic,
-                        event: { name: 'accountsChanged', data: payload },
-                        chainId: toCaipChainId(this.wallet.currentChainId),
-                    });
+                    const namespaces = session.namespaces;
+                    if (namespaces.eip155) {
+                        const accounts = Array.isArray(payload) ? payload.filter(isAddressString) : [];
+                        if (accounts.length > 0) {
+                            const caipChains = (namespaces.eip155.chains ?? this.chains.map(toCaipChainId)).filter((chainId) => typeof chainId === 'string');
+                            const nextAccounts = eip155AccountsFor(caipChains, accounts);
+                            if (!arraysEqual(namespaces.eip155.accounts, nextAccounts)) {
+                                const updated = {
+                                    ...namespaces,
+                                    eip155: {
+                                        ...namespaces.eip155,
+                                        accounts: nextAccounts,
+                                    },
+                                };
+                                await this.client.update({ topic: session.topic, namespaces: updated });
+                                session.namespaces = updated;
+                            }
+                        }
+                        await this.client.emit({
+                            topic: session.topic,
+                            event: { name: 'accountsChanged', data: payload },
+                            chainId: toCaipChainId(this.wallet.currentChainId),
+                        });
+                    }
+                    if (this.solana && namespaces.solana) {
+                        const accounts = Array.isArray(payload) && payload.length > 0 ? [this.solana.publicKey] : [];
+                        for (const chainId of namespaces.solana.chains ?? this.solana.chains) {
+                            await this.client.emit({
+                                topic: session.topic,
+                                event: { name: 'accountsChanged', data: accounts },
+                                chainId,
+                            });
+                        }
+                    }
                 }
                 else if (event === 'disconnect') {
                     await this.client