@dynamic-labs/solana 4.38.0 → 4.40.0

package/CHANGELOG.md

@@ -1,4 +1,25 @@
 
+## [4.40.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.39.0...v4.40.0) (2025-10-22)
+
+
+### Features
+
+* add Wallet Connect Solana as a wallet option ([#9719](https://github.com/dynamic-labs/dynamic-auth/issues/9719)) ([ece5f6b](https://github.com/dynamic-labs/dynamic-auth/commit/ece5f6b36c1fbefdf05cf8203fe0fee0b2e8ed3d))
+* make updates to crypto.com onramp flow ([#9746](https://github.com/dynamic-labs/dynamic-auth/issues/9746)) ([22040d2](https://github.com/dynamic-labs/dynamic-auth/commit/22040d28d0d66b84f5c3be9bed4cfce7f1978944))
+
+
+### Bug Fixes
+
+* return undefined if json payload is undefined in parse token ([#9750](https://github.com/dynamic-labs/dynamic-auth/issues/9750)) ([5751198](https://github.com/dynamic-labs/dynamic-auth/commit/575119867c93f89062e96e30c02b128161fb9675))
+
+## [4.39.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.38.0...v4.39.0) (2025-10-17)
+
+
+### Features
+
+* add crypto.com as an onramp option in deposit ([#9580](https://github.com/dynamic-labs/dynamic-auth/issues/9580)) ([4988acc](https://github.com/dynamic-labs/dynamic-auth/commit/4988accfeafa5556297ad6e9873073e30c504c7f)), closes [#3](https://github.com/dynamic-labs/dynamic-auth/issues/3)
+* add sui non-native token sending thru dynamic widget ([#9715](https://github.com/dynamic-labs/dynamic-auth/issues/9715)) ([9d9ea3b](https://github.com/dynamic-labs/dynamic-auth/commit/9d9ea3b233706766516b89d725a52d63cceb01f6))
+
 ## [4.38.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.37.2...v4.38.0) (2025-10-14)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.38.0";
+var version = "4.40.0";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.38.0";
+var version = "4.40.0";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/solana",
-  "version": "4.38.0",
+  "version": "4.40.0",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,6 +18,7 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
+    "@dynamic-labs/wallet-connect": "4.40.0",
     "@solana/web3.js": "1.98.1",
     "@wallet-standard/app": "1.0.1",
     "@wallet-standard/base": "1.0.1",
@@ -25,17 +26,21 @@
     "@wallet-standard/experimental-features": "0.1.1",
     "bs58": "5.0.0",
     "tweetnacl": "1.0.3",
-    "@dynamic-labs/assert-package-version": "4.38.0",
-    "@dynamic-labs/embedded-wallet-solana": "4.38.0",
-    "@dynamic-labs/logger": "4.38.0",
-    "@dynamic-labs/rpc-providers": "4.38.0",
-    "@dynamic-labs/sdk-api-core": "0.0.805",
-    "@dynamic-labs/solana-core": "4.38.0",
-    "@dynamic-labs/types": "4.38.0",
-    "@dynamic-labs/utils": "4.38.0",
-    "@dynamic-labs/waas-svm": "4.38.0",
-    "@dynamic-labs/wallet-book": "4.38.0",
-    "@dynamic-labs/wallet-connector-core": "4.38.0"
+    "@walletconnect/sign-client": "2.21.5",
+    "@walletconnect/utils": "2.21.5",
+    "@walletconnect/types": "2.21.5",
+    "@dynamic-labs/assert-package-version": "4.40.0",
+    "@dynamic-labs/embedded-wallet-solana": "4.40.0",
+    "@dynamic-labs/logger": "4.40.0",
+    "@dynamic-labs/rpc-providers": "4.40.0",
+    "@dynamic-labs/sdk-api-core": "0.0.813",
+    "@dynamic-labs/solana-core": "4.40.0",
+    "@dynamic-labs/types": "4.40.0",
+    "@dynamic-labs/utils": "4.40.0",
+    "@dynamic-labs/waas-svm": "4.40.0",
+    "@dynamic-labs/wallet-book": "4.40.0",
+    "@dynamic-labs/wallet-connector-core": "4.40.0",
+    "eventemitter3": "5.0.1"
   },
   "peerDependencies": {}
 }

package/src/SolanaWalletConnectors.cjs

@@ -13,6 +13,7 @@ require('../_virtual/_tslib.cjs');
 require('@solana/web3.js');
 require('bs58');
 require('./utils/logger.cjs');
+var getSolanaWalletConnectConnector = require('./walletConnect/utils/getSolanaWalletConnectConnector/getSolanaWalletConnectConnector.cjs');
 
 const SolanaWalletConnectors = (
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -23,6 +24,7 @@ props) => [
     ...waasSvm.DynamicWaasSVMConnectors(),
     Phantom.Phantom,
     FallbackSolanaConnector.FallbackSolanaConnector,
+    getSolanaWalletConnectConnector.getSolanaWalletConnectConnector(),
 ];
 
 exports.SolanaWalletConnectors = SolanaWalletConnectors;

package/src/SolanaWalletConnectors.js

@@ -9,6 +9,7 @@ import '../_virtual/_tslib.js';
 import '@solana/web3.js';
 import 'bs58';
 import './utils/logger.js';
+import { getSolanaWalletConnectConnector } from './walletConnect/utils/getSolanaWalletConnectConnector/getSolanaWalletConnectConnector.js';
 
 const SolanaWalletConnectors = (
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -19,6 +20,7 @@ props) => [
     ...DynamicWaasSVMConnectors(),
     Phantom,
     FallbackSolanaConnector,
+    getSolanaWalletConnectConnector(),
 ];
 
 export { SolanaWalletConnectors };

package/src/walletConnect/SolanaWalletConnectConnector/SolanaWalletConnectConnector.cjs

@@ -0,0 +1,411 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var bs58 = require('bs58');
+var utils$1 = require('@walletconnect/utils');
+var web3_js = require('@solana/web3.js');
+var EventEmitter = require('eventemitter3');
+var solanaCore = require('@dynamic-labs/solana-core');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var walletConnect = require('@dynamic-labs/wallet-connect');
+var logger = require('../../utils/logger.cjs');
+var createSolanaSignerForWalletConnect = require('./createSolanaSignerForWalletConnect/createSolanaSignerForWalletConnect.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+const WC_SOLANA_CURRENT_CHAIN_KEY = 'dynamic-wc2-solana-current-chain';
+class SolanaWalletConnectConnector extends solanaCore.SolanaWalletConnector {
+    constructor(opts) {
+        super(opts);
+        this.activeAccountEmitter = new EventEmitter__default["default"]();
+        this.isInitialized = false;
+        this.canConnectViaQrCode = true;
+        this.isWalletConnect = true;
+        this.canHandleMultipleConnections = false;
+        this.name = opts.walletName;
+        const storedChainId = utils.StorageService.getItem(WC_SOLANA_CURRENT_CHAIN_KEY);
+        if (storedChainId) {
+            this.setNetworkId(storedChainId);
+        }
+        if (!opts.projectId) {
+            throw new utils.DynamicError('WalletConnect project ID is required');
+        }
+    }
+    get deepLinkPreference() {
+        var _a;
+        return (_a = this.constructorProps.deepLinkPreference) !== null && _a !== void 0 ? _a : 'native';
+    }
+    /**
+     * Accesses the sign client singleton instance, and throws if it is not
+     * immediately available.
+     */
+    get signClient() {
+        if (!this.signClientReference) {
+            throw new utils.DynamicError('Failed to access sign client for Wallet Connect Solana: Sign client not initialized');
+        }
+        return this.signClientReference;
+    }
+    getSupportedNetworks() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.session) {
+                return [];
+            }
+            const sessionChains = (_b = (_a = this.session.namespaces.solana) === null || _a === void 0 ? void 0 : _a.chains) !== null && _b !== void 0 ? _b : [];
+            return this.solNetworks
+                .filter((network) => sessionChains.includes(`solana:${network.genesisHash}`))
+                .map((network) => network.chainId.toString());
+        });
+    }
+    getActiveAddress() {
+        var _a, _b;
+        if (!this.session) {
+            return undefined;
+        }
+        return (_b = (_a = this.session.namespaces.solana) === null || _a === void 0 ? void 0 : _a.accounts) === null || _b === void 0 ? void 0 : _b[0].split(':')[2];
+    }
+    listenToActiveAccountChange(listener) {
+        this.activeAccountEmitter.on('activeAccountDidChange', listener);
+        return () => {
+            this.activeAccountEmitter.off('activeAccountDidChange', listener);
+        };
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return createSolanaSignerForWalletConnect.createSolanaSignerForWalletConnect({ walletConnector: this });
+        });
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('Connect method not implemented.');
+        });
+    }
+    init() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.isInitialized) {
+                return;
+            }
+            this.isInitialized = true;
+            const { appLogoUrl, appName, projectId } = this.constructorProps;
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] init called');
+            this.signClientPromise = walletConnect.getSignClientSingleton({
+                appIcon: appLogoUrl !== null && appLogoUrl !== void 0 ? appLogoUrl : '',
+                appName: appName !== null && appName !== void 0 ? appName : '',
+                projectId,
+            });
+            this.signClientReference = yield this.signClientPromise;
+            this.setupWCEventListeners();
+        });
+    }
+    setupWCEventListeners() {
+        logger.logger.debug('[SolanaWalletConnect] setupWCEventListeners');
+        this.signClient.on('session_event', ({ params: { event }, topic }) => {
+            var _a, _b;
+            // Ignore events for wallets other than the one we are connected to
+            if (!this.session || topic !== this.session.topic) {
+                return;
+            }
+            if (event.name === 'chainChanged') {
+                const chainParam = event.data;
+                let chainId = chainParam;
+                // Handle potentially CAIP-2 format
+                if (chainParam.startsWith('solana:')) {
+                    const chainHash = chainParam.split(':')[1];
+                    chainId =
+                        (_b = (_a = this.solNetworks
+                            .find((network) => network.genesisHash === chainHash)) === null || _a === void 0 ? void 0 : _a.networkId.toString()) !== null && _b !== void 0 ? _b : chainParam;
+                }
+                logger.logger.debug('[SolanaWalletConnect] onChainChange', { chainId });
+                if (chainId === this.getNetworkId()) {
+                    logger.logger.debug(`[SolanaWalletConnect] onChainChange - ignoring chainChanged event with same chain id as current chain id: ${chainId}`);
+                    return;
+                }
+                // This will already emit an event so no need to call this.emit('chainChange', { chain: chainId });
+                this.switchNetwork({ networkChainId: parseInt(chainId) });
+                return;
+            }
+            if (event.name === 'accountsChanged') {
+                const accountsParam = event.data;
+                const accounts = utils.filterDuplicates(accountsParam.map((account) => {
+                    // Handle potentially CAIP-10 format
+                    if (account.startsWith('solana:')) {
+                        return account.split(':')[2];
+                    }
+                    return account;
+                }));
+                logger.logger.debug('[SolanaWalletConnect] onAccountChanged', { accounts });
+                this.emit('accountChange', { accounts });
+                return;
+            }
+            if (event.name === 'disconnected') {
+                logger.logger.debug('[SolanaWalletConnect] onDisconnect');
+                this.emit('disconnect');
+                this.endSession();
+                return;
+            }
+        });
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.debug('[SolanaWalletConnect] endSession');
+            this.connectionUri = undefined;
+            if (!this.session) {
+                return;
+            }
+            yield this.signClient.disconnect({
+                reason: utils$1.SDK_ERRORS.USER_DISCONNECTED,
+                topic: this.session.topic,
+            });
+            this.session = undefined;
+        });
+    }
+    displayUri(connectionOpts) {
+        if (!this.connectionUri) {
+            return;
+        }
+        logger.logger.debug('[SolanaWalletConnect] handleDisplayURI', this.connectionUri);
+        walletConnectorCore.performPlatformSpecificConnectionMethod(this.connectionUri, this.metadata.deepLinks, {
+            onDesktopUri: connectionOpts === null || connectionOpts === void 0 ? void 0 : connectionOpts.onDesktopUri,
+            onDisplayUri: connectionOpts === null || connectionOpts === void 0 ? void 0 : connectionOpts.onDisplayUri,
+        }, this.deepLinkPreference);
+    }
+    getAddress(opts) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            logger.logger.debug('[SolanaWalletConnect] getAddress', opts);
+            /**
+             * In mobile/Safari, if the user just navigates back after the deeplink prompt the connection
+             * is not rejected, so the previous connection URI is still valid and we can use it to handle the connection
+             */
+            if (this.connectionUri) {
+                logger.logger.debug('[SolanaWalletConnect] getAddress - connecting to WalletConnect with existing connection URI');
+                this.displayUri(opts);
+                return;
+            }
+            /**
+             * If we are already connected to a session, we need to end it first
+             */
+            yield this.endSession();
+            logger.logger.logVerboseTroubleshootingMessage('[WalletConnectConnector] getAddress', {
+                inAppBrowserUrl: (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.inAppBrowserUrl,
+                isMobile: utils.isMobile(),
+                mobileExperience: this.mobileExperience,
+            });
+            if (utils.isMobile() &&
+                ((_b = this.metadata) === null || _b === void 0 ? void 0 : _b.inAppBrowserUrl) &&
+                this.mobileExperience === 'in-app-browser') {
+                const inAppBrowserCompiledTemplate = utils.template(this.metadata.inAppBrowserUrl);
+                const { href } = utils.PlatformService.getUrl();
+                const deepLink = inAppBrowserCompiledTemplate({
+                    encodedDappURI: encodeURIComponent(href),
+                });
+                utils.PlatformService.openURL(deepLink);
+                return;
+            }
+            logger.logger.debug('[SolanaWalletConnect] getAddress - connecting to WalletConnect');
+            const chains = this.solNetworks.map((network) => `solana:${network.genesisHash}`);
+            try {
+                const { approval, uri } = yield this.signClient.connect({
+                    optionalNamespaces: {
+                        solana: {
+                            chains,
+                            events: ['chainChanged', 'accountsChanged', 'disconnected'],
+                            methods: [
+                                'solana_signMessage',
+                                'solana_signTransaction',
+                                'solana_requestAccounts',
+                                'solana_getAccounts',
+                                'solana_signAllTransactions',
+                                'solana_signAndSendTransaction',
+                            ],
+                        },
+                    },
+                });
+                logger.logger.debug('[SolanaWalletConnect] getAddress - connection URI', uri);
+                this.connectionUri = uri;
+                this.displayUri(opts);
+                this.session = yield approval();
+                const activeAddress = this.getActiveAddress();
+                this.activeAccountEmitter.emit('activeAccountDidChange', activeAddress);
+                return activeAddress;
+            }
+            finally {
+                this.connectionUri = undefined;
+            }
+        });
+    }
+    signClientRequest(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ method, params, }) {
+            var _b, _c;
+            if (!this.session) {
+                throw new utils.DynamicError('Session not initialized. Please connect to a wallet first.');
+            }
+            const chainHash = (_c = (_b = this.getSelectedNetwork()) === null || _b === void 0 ? void 0 : _b.genesisHash) !== null && _c !== void 0 ? _c : this.solNetworks[0].genesisHash;
+            const chainId = `solana:${chainHash}`;
+            const requestPromise = this.signClient.request({
+                chainId,
+                request: {
+                    method,
+                    params,
+                },
+                topic: this.session.topic,
+            });
+            this.deepLinkIfApplicable({ method });
+            return requestPromise;
+        });
+    }
+    deepLinkIfApplicable(params) {
+        const methodsThatRequireDeepLink = [
+            'solana_signMessage',
+            'solana_signTransaction',
+            'solana_signAllTransactions',
+            'solana_signAndSendTransaction',
+        ];
+        const deepLink = this.getDeepLink();
+        if (utils.isMobile() &&
+            deepLink &&
+            methodsThatRequireDeepLink.includes(params.method)) {
+            utils.PlatformService.openURL(deepLink);
+        }
+    }
+    signMessage(messageToSign, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] signMessage', messageToSign, options);
+            const encodedMessage = new TextEncoder().encode(messageToSign);
+            const decodedSignature = yield this.signEncodedMessage(encodedMessage, options);
+            return utils.bufferToBase64(decodedSignature);
+        });
+    }
+    signEncodedMessage(encodedMessage, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] signEncodedMessage', encodedMessage, options);
+            if (options === null || options === void 0 ? void 0 : options.address) {
+                yield this.validateActiveWallet(options.address);
+            }
+            const activeAddress = this.getActiveAddress();
+            if (!activeAddress) {
+                throw new utils.DynamicError('No active address found');
+            }
+            const { signature } = yield this.signClientRequest({
+                method: 'solana_signMessage',
+                params: {
+                    message: bs58__default["default"].encode(encodedMessage),
+                    pubkey: new web3_js.PublicKey(activeAddress).toBase58(),
+                },
+            });
+            return bs58__default["default"].decode(signature);
+        });
+    }
+    serializeTransaction(transaction) {
+        const serialized = transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+        return bs58__default["default"].encode(new Uint8Array(serialized));
+    }
+    signTransaction(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const activeAddress = this.getActiveAddress();
+            if (!activeAddress) {
+                throw new utils.DynamicError('Active account address is required');
+            }
+            const serializedTransaction = this.serializeTransaction(transaction);
+            const { transaction: signedTransaction } = yield this.signClientRequest({
+                method: 'solana_signTransaction',
+                params: { transaction: serializedTransaction },
+            });
+            const decodedTransaction = bs58__default["default"].decode(signedTransaction);
+            if (solanaCore.isVersionedTransaction(transaction)) {
+                return web3_js.VersionedTransaction.deserialize(decodedTransaction);
+            }
+            return web3_js.Transaction.from(decodedTransaction);
+        });
+    }
+    signAllTransactions(transactions) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const serializedTransactions = transactions.map(this.serializeTransaction);
+            const { transactions: signedTransactions } = yield this.signClientRequest({
+                method: 'solana_signAllTransactions',
+                params: { transactions: serializedTransactions },
+            });
+            return signedTransactions.map((signedTransaction, index) => {
+                const originalTransaction = transactions[index];
+                const decodedTransaction = bs58__default["default"].decode(signedTransaction);
+                if (solanaCore.isVersionedTransaction(originalTransaction)) {
+                    return web3_js.VersionedTransaction.deserialize(decodedTransaction);
+                }
+                return web3_js.Transaction.from(decodedTransaction);
+            });
+        });
+    }
+    signAndSendTransaction(transaction, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const serializedTransaction = this.serializeTransaction(transaction);
+            const { signature } = yield this.signClientRequest({
+                method: 'solana_signAndSendTransaction',
+                params: { options, transaction: serializedTransaction },
+            });
+            return signature;
+        });
+    }
+    getDeepLink() {
+        const deepLink = walletConnectorCore.getDeepLink({
+            deepLinks: this.metadata.deepLinks,
+            mode: 'regular',
+            preference: this.deepLinkPreference,
+            // TODO: verify whether we need the uri
+            // uri: provider.signer.uri,
+        });
+        logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] getDeepLink - deepLink', deepLink);
+        if (!deepLink) {
+            return;
+        }
+        if (this.session) {
+            // we need to include the session topic here because it helps the wallet
+            // auto redirect back to the dapp after signing
+            return `${deepLink}?sessionTopic=${this.session.topic}`;
+        }
+        return deepLink;
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            /**
+             * Each session has a single account (it might be on multiple chains hence the array),
+             * but that account is stored as a CAIP-10 string, so we need to parse it to get the address
+             */
+            const account = this.getActiveAddress();
+            if (!account) {
+                return [];
+            }
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] getConnectedAccounts - activeAccounts', [account]);
+            return [account];
+        });
+    }
+    getConnectionUri() {
+        return this.connectionUri;
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.debug('[SolanaWalletConnect] validateActiveWallet - validating wallet', expectedAddress);
+            const [activeAddress] = yield this.getConnectedAccounts();
+            const isWalletActive = walletConnectorCore.isSameAddress(activeAddress, expectedAddress, this.connectedChain);
+            if (isWalletActive) {
+                logger.logger.debug('[SolanaWalletConnect] validateActiveWallet - wallet is active');
+                return;
+            }
+            return this.handleWalletNotActive({
+                activeAddress,
+                expectedAddress,
+            });
+        });
+    }
+}
+
+exports.SolanaWalletConnectConnector = SolanaWalletConnectConnector;

package/src/walletConnect/SolanaWalletConnectConnector/SolanaWalletConnectConnector.d.ts

@@ -0,0 +1,63 @@
+import SignClient from '@walletconnect/sign-client';
+import type { SessionTypes } from '@walletconnect/types';
+import { SendOptions, Transaction, VersionedTransaction } from '@solana/web3.js';
+import { ISolanaSigner, SolanaWalletConnector, SolanaWalletConnectorOpts } from '@dynamic-labs/solana-core';
+import { DeepLinkVariant, GetAddressOpts, IWalletConnectConnector } from '@dynamic-labs/wallet-connector-core';
+export type SolanaWalletConnectConnectorOpts = SolanaWalletConnectorOpts & {
+    projectId?: string;
+    walletName: string;
+    deepLinkPreference?: DeepLinkVariant;
+    appLogoUrl?: string;
+    appName?: string;
+};
+export declare class SolanaWalletConnectConnector extends SolanaWalletConnector implements IWalletConnectConnector {
+    name: string;
+    private signClientReference;
+    private signClientPromise;
+    /**
+     * When a WalletConnect connection is initiated, we store the connection URI
+     * so we can use it to handle the URI for wallet app connection and still have
+     * it if we need it again before the connection is established (for instance,
+     * when a user navigates back to the dapp after a deeplink and then attempts to deeplink again)
+     */
+    private connectionUri;
+    session: SessionTypes.Struct | undefined;
+    private activeAccountEmitter;
+    isInitialized: boolean;
+    canConnectViaQrCode: boolean;
+    isWalletConnect: boolean;
+    canHandleMultipleConnections: boolean;
+    constructor(opts: SolanaWalletConnectConnectorOpts);
+    get deepLinkPreference(): DeepLinkVariant;
+    /**
+     * Accesses the sign client singleton instance, and throws if it is not
+     * immediately available.
+     */
+    get signClient(): SignClient;
+    getSupportedNetworks(): Promise<string[]>;
+    getActiveAddress(): string | undefined;
+    listenToActiveAccountChange(listener: (account: string) => void): VoidFunction;
+    getSigner(): Promise<ISolanaSigner>;
+    connect(): Promise<void>;
+    init(): Promise<void>;
+    private setupWCEventListeners;
+    endSession(): Promise<void>;
+    private displayUri;
+    getAddress(opts?: GetAddressOpts): Promise<string | undefined>;
+    private signClientRequest;
+    private deepLinkIfApplicable;
+    signMessage(messageToSign: string, options?: {
+        address?: string;
+    }): Promise<string | undefined>;
+    signEncodedMessage(encodedMessage: Uint8Array, options?: {
+        address?: string;
+    }): Promise<Uint8Array>;
+    private serializeTransaction;
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
+    signAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<string>;
+    getDeepLink(): string | undefined;
+    getConnectedAccounts(): Promise<string[]>;
+    getConnectionUri(): string | undefined;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+}