@reown/appkit-adapter-solana 1.3.2 → 1.4.1

package/dist/esm/src/client.js

@@ -1,478 +1,322 @@
-import { Connection } from '@solana/web3.js';
-import { AccountController, ApiController, ChainController, CoreHelperUtil, EventsController, AlertController } from '@reown/appkit-core';
-import { ConstantsUtil as CommonConstantsUtil, SafeLocalStorage, SafeLocalStorageKeys } from '@reown/appkit-common';
+import { AdapterBlueprint } from '@reown/appkit/adapters';
+import { ConstantsUtil as CommonConstantsUtil } from '@reown/appkit-common';
+import { AlertController, CoreHelperUtil, EventsController } from '@reown/appkit-core';
+import { ConstantsUtil, ErrorUtil } from '@reown/appkit-utils';
+import { Connection, PublicKey } from '@solana/web3.js';
 import { SolConstantsUtil } from '@reown/appkit-utils/solana';
 import { SolStoreUtil } from './utils/SolanaStoreUtil.js';
-import { PublicKey } from '@solana/web3.js';
-import UniversalProvider, {} from '@walletconnect/universal-provider';
 import { watchStandard } from './utils/watchStandard.js';
-import { WalletConnectProvider } from './providers/WalletConnectProvider.js';
 import { AuthProvider } from './providers/AuthProvider.js';
-import { W3mFrameHelpers, W3mFrameProvider, W3mFrameRpcConstants } from '@reown/appkit-wallet';
-import { ConstantsUtil as CoreConstantsUtil } from '@reown/appkit-core';
-import { withSolanaNamespace } from './utils/withSolanaNamespace.js';
-import { ProviderUtil } from '@reown/appkit/store';
+import { CoinbaseWalletProvider } from './providers/CoinbaseWalletProvider.js';
+import { WcHelpersUtil } from '@reown/appkit';
 import { W3mFrameProviderSingleton } from '@reown/appkit/auth-provider';
-import { ConstantsUtil, ErrorUtil } from '@reown/appkit-utils';
+import { withSolanaNamespace } from './utils/withSolanaNamespace.js';
+import UniversalProvider from '@walletconnect/universal-provider';
 import { createSendTransaction } from './utils/createSendTransaction.js';
-import { CoinbaseWalletProvider } from './providers/CoinbaseWalletProvider.js';
-import base58 from 'bs58';
-export class SolanaAdapter {
-    constructor(options) {
-        this.appKit = undefined;
-        this.options = undefined;
-        this.caipNetworks = [];
-        this.chainNamespace = CommonConstantsUtil.CHAIN.SOLANA;
-        this.availableProviders = [];
-        this.defaultCaipNetwork = undefined;
+import { handleMobileWalletRedirection } from './utils/handleMobileWalletRedirection.js';
+import { WalletConnectProvider } from './providers/WalletConnectProvider.js';
+export class SolanaAdapter extends AdapterBlueprint {
+    constructor(options = {}) {
+        super({});
         this.adapterType = 'solana';
-        const { wallets, connectionSettings = 'confirmed' } = options;
-        this.wallets = wallets;
-        this.connectionSettings = connectionSettings;
-        ChainController.subscribeKey('activeCaipNetwork', caipNetwork => {
-            const caipAddress = this.appKit?.getCaipAddress(this.chainNamespace);
-            const isSolanaAddress = caipAddress?.startsWith('solana:');
-            const isSolanaNetwork = caipNetwork?.chainNamespace === this.chainNamespace;
-            if (caipAddress && isSolanaAddress && isSolanaNetwork) {
-                this.syncAccount({
-                    address: CoreHelperUtil.getPlainAddress(caipAddress),
-                    caipNetwork
-                });
-            }
-        });
-        AccountController.subscribeKey('caipAddress', caipAddress => {
-            const isSolanaAddress = caipAddress?.startsWith('solana:');
-            const caipNetwork = ChainController.state.activeCaipNetwork;
-            const isSolanaNetwork = caipNetwork?.chainNamespace === this.chainNamespace;
-            if (caipAddress && isSolanaAddress && isSolanaNetwork) {
-                this.syncAccount({
-                    address: CoreHelperUtil.getPlainAddress(caipAddress),
-                    caipNetwork
-                });
-            }
-        }, this.chainNamespace);
-    }
-    construct(appKit, options) {
-        const { projectId } = options;
-        this.appKit = appKit;
-        this.options = options;
-        this.caipNetworks = options.networks;
-        this.defaultCaipNetwork = options.defaultNetwork;
-        if (!projectId) {
-            throw new Error('Solana:construct - projectId is undefined');
-        }
-        this.networkControllerClient = {
-            switchCaipNetwork: async (caipNetwork) => {
-                if (caipNetwork) {
-                    try {
-                        await this.switchNetwork(caipNetwork);
-                    }
-                    catch (error) {
-                        console.warn('Error switching network', error);
-                    }
-                }
-            },
-            getApprovedCaipNetworksData: async () => {
-                if (this.provider) {
-                    return Promise.resolve({
-                        supportsAllNetworks: false,
-                        approvedCaipNetworkIds: this.provider.chains.map(chain => chain.caipNetworkId)
-                    });
-                }
-                return Promise.resolve({
-                    supportsAllNetworks: false,
-                    approvedCaipNetworkIds: []
-                });
-            }
-        };
-        this.connectionControllerClient = {
-            connectExternal: async ({ id }) => {
-                const externalProvider = this.availableProviders.find(provider => provider.name.toLocaleLowerCase() === id.toLocaleLowerCase());
-                const isAuthProvider = id.toLocaleLowerCase() === ConstantsUtil.AUTH_CONNECTOR_ID.toLocaleLowerCase();
-                if (!externalProvider) {
-                    throw Error('connectionControllerClient:connectExternal - adapter was undefined');
-                }
-                const chainNamespace = this.appKit?.getActiveChainNamespace();
-                if (chainNamespace === this.chainNamespace || !isAuthProvider) {
-                    await this.setProvider(externalProvider);
-                }
-            },
-            disconnect: async () => {
-                await ProviderUtil.getProvider('solana')?.disconnect();
-                this.appKit?.resetAccount(this.chainNamespace);
-            },
-            signMessage: async (message) => {
-                const provider = ProviderUtil.state.providers['solana'];
-                if (!provider) {
-                    throw new Error('connectionControllerClient:signMessage - provider is undefined');
-                }
-                const signature = await provider.signMessage(new TextEncoder().encode(message));
-                return base58.encode(signature);
-            },
-            estimateGas: async (params) => {
-                if (params.chainNamespace !== CommonConstantsUtil.CHAIN.SOLANA) {
-                    throw new Error('Chain namespace is not supported');
-                }
-                const connection = SolStoreUtil.state.connection;
-                if (!connection || !this.provider) {
-                    throw new Error('Connection is not set');
-                }
-                const transaction = await createSendTransaction({
-                    provider: this.provider,
-                    connection,
-                    to: '11111111111111111111111111111111',
-                    value: 1
-                });
-                const fee = await transaction.getEstimatedFee(connection);
-                return BigInt(fee || 0);
-            },
-            getEnsAvatar: async (value) => await Promise.resolve(value),
-            getEnsAddress: async (value) => await Promise.resolve(value),
-            writeContract: async () => await Promise.resolve('0x'),
-            getCapabilities: async () => await Promise.resolve('0x'),
-            grantPermissions: async () => await Promise.resolve('0x'),
-            revokePermissions: async () => await Promise.resolve('0x'),
-            sendTransaction: async (params) => {
-                if (params.chainNamespace !== CommonConstantsUtil.CHAIN.SOLANA) {
-                    throw new Error('Chain namespace is not supported');
-                }
-                const connection = SolStoreUtil.state.connection;
-                const address = this.appKit?.getAddress(this.chainNamespace);
-                if (!connection || !address || !this.provider) {
-                    throw new Error('Connection is not set');
-                }
-                const transaction = await createSendTransaction({
-                    provider: this.provider,
-                    connection,
-                    to: params.to,
-                    value: params.value
-                });
-                const result = await this.provider.sendTransaction(transaction, connection);
-                await new Promise(resolve => {
-                    const interval = setInterval(async () => {
-                        const status = await connection.getSignatureStatus(result);
-                        if (status?.value) {
-                            clearInterval(interval);
-                            resolve();
-                        }
-                    }, 1000);
-                });
-                await this.syncBalance(address);
-                return result;
-            },
-            parseUnits: () => BigInt(0),
-            formatUnits: () => '',
-            checkInstalled: (ids = []) => {
-                const availableIds = new Set(this.availableProviders.map(provider => provider.name));
-                return ids.some(id => availableIds.has(id));
-            }
-        };
-        ChainController.state.chains.set(this.chainNamespace, {
-            chainNamespace: this.chainNamespace,
-            connectionControllerClient: this.connectionControllerClient,
-            networkControllerClient: this.networkControllerClient,
-            adapterType: this.adapterType,
-            caipNetworks: this.caipNetworks
-        });
-        ProviderUtil.subscribeProviders(providers => {
-            if (providers['solana'] && providers['solana'] instanceof UniversalProvider) {
-                const walletConnectProvider = this.getSolanaWalletConnectProvider(providers['solana']);
-                ProviderUtil.setProvider(this.chainNamespace, walletConnectProvider);
-            }
-        });
-        this.syncRequestedNetworks(this.caipNetworks);
-        this.initializeProviders({
-            relayUrl: 'wss://relay.walletconnect.com',
-            metadata: options.metadata,
-            projectId: options.projectId
-        });
-        this.syncRequestedNetworks(this.caipNetworks);
-        ChainController.subscribeKey('activeCaipNetwork', (newCaipNetwork) => {
-            const newChain = this.caipNetworks.find(_chain => _chain.id === newCaipNetwork?.id);
-            if (!newChain) {
-                return;
-            }
-            if (ChainController.state.activeCaipNetwork && this.appKit?.getIsConnectedState()) {
-                ApiController.reFetchWallets();
-            }
-        });
+        this.providerHandlers = null;
+        this.namespace = CommonConstantsUtil.CHAIN.SOLANA;
+        this.connectionSettings = options.connectionSettings || 'confirmed';
+        this.wallets = options.wallets;
         EventsController.subscribe(state => {
             if (state.data.event === 'SELECT_WALLET') {
                 const isMobile = CoreHelperUtil.isMobile();
                 const isClient = CoreHelperUtil.isClient();
                 if (isMobile && isClient) {
-                    if (state.data.properties?.name === 'Phantom' && !('phantom' in window)) {
-                        const href = window.location.href;
-                        const protocol = href.startsWith('https') ? 'https' : 'http';
-                        const host = href.split('/')[2];
-                        const ref = `${protocol}://${host}`;
-                        window.location.href = `https://phantom.app/ul/browse/${href}?ref=${ref}`;
-                    }
-                    if (state.data.properties?.name === 'Coinbase Wallet' && !('coinbaseSolana' in window)) {
-                        const href = window.location.href;
-                        window.location.href = `https://go.cb-w.com/dapp?cb_url=${href}`;
-                    }
+                    handleMobileWalletRedirection(state.data.properties);
                 }
             }
         });
     }
-    getWalletConnection() {
-        return SolStoreUtil.state.connection;
-    }
-    async syncAccount({ address, caipNetwork }) {
-        if (address && caipNetwork) {
-            SolStoreUtil.setConnection(new Connection(caipNetwork.rpcUrls.default.http?.[0], this.connectionSettings));
-            this.appKit?.setAllAccounts([{ address, type: 'eoa' }], this.chainNamespace);
-            this.appKit?.setCaipAddress(`${this.chainNamespace}:${caipNetwork.id}:${address}`, this.chainNamespace);
-            await this.syncNetwork(address);
+    syncConnectors(options, appKit) {
+        if (!options.projectId) {
+            AlertController.open(ErrorUtil.ALERT_ERRORS.PROJECT_ID_NOT_CONFIGURED, 'error');
         }
-        else {
-            this.appKit?.resetWcConnection();
-            this.appKit?.resetNetwork(this.chainNamespace);
-            this.appKit?.resetAccount(this.chainNamespace);
+        const emailEnabled = options.features?.email !== false;
+        const socialsEnabled = options.features?.socials !== false &&
+            Array.isArray(options.features?.socials) &&
+            options.features.socials.length > 0;
+        if (emailEnabled || socialsEnabled) {
+            this.w3mFrameProvider = W3mFrameProviderSingleton.getInstance({
+                projectId: options.projectId,
+                chainId: withSolanaNamespace(appKit?.getCaipNetwork(this.namespace)?.id),
+                onTimeout: () => {
+                    AlertController.open(ErrorUtil.ALERT_ERRORS.INVALID_APP_CONFIGURATION, 'error');
+                }
+            });
+            this.authProvider = new AuthProvider({
+                getProvider: () => this.w3mFrameProvider,
+                getActiveChain: () => appKit.getCaipNetwork(this.namespace),
+                getActiveNamespace: () => appKit.getActiveChainNamespace(),
+                getSession: () => this.authSession,
+                setSession: session => {
+                    this.authSession = session;
+                },
+                chains: this.caipNetworks
+            });
+            this.addConnector({
+                id: ConstantsUtil.AUTH_CONNECTOR_ID,
+                type: 'AUTH',
+                provider: this.authProvider,
+                name: 'Auth',
+                chain: this.namespace,
+                chains: []
+            });
         }
+        if ('coinbaseSolana' in window) {
+            this.addConnector({
+                id: 'coinbaseWallet',
+                type: 'EXTERNAL',
+                provider: new CoinbaseWalletProvider({
+                    provider: window.coinbaseSolana,
+                    chains: this.caipNetworks,
+                    getActiveChain: () => appKit.getCaipNetwork(this.namespace)
+                }),
+                name: 'Coinbase Wallet',
+                chain: this.namespace,
+                chains: []
+            });
+        }
+        watchStandard(this.caipNetworks, () => appKit.getCaipNetwork(this.namespace), (...providers) => {
+            providers.forEach(provider => {
+                this.addConnector({
+                    id: provider.name,
+                    type: 'ANNOUNCED',
+                    provider: provider,
+                    imageUrl: provider.icon,
+                    name: provider.name,
+                    chain: CommonConstantsUtil.CHAIN.SOLANA,
+                    chains: []
+                });
+            });
+        });
     }
-    async syncBalance(address = this.appKit?.getAddress(this.chainNamespace)) {
-        if (!address) {
-            return;
+    async getEnsAddress(params) {
+        return { address: params.name };
+    }
+    async writeContract() {
+        return Promise.resolve({
+            hash: ''
+        });
+    }
+    async getCapabilities() {
+        return Promise.resolve({});
+    }
+    async grantPermissions() {
+        return Promise.resolve({});
+    }
+    async revokePermissions() {
+        return Promise.resolve('0x');
+    }
+    async signMessage(params) {
+        const walletStandardProvider = params.provider;
+        if (!walletStandardProvider) {
+            throw new Error('connectionControllerClient:signMessage - provider is undefined');
         }
-        if (!SolStoreUtil.state.connection) {
+        const signature = await walletStandardProvider.signMessage(new TextEncoder().encode(params.message));
+        return {
+            signature: new TextDecoder().decode(signature)
+        };
+    }
+    async estimateGas(params) {
+        const connection = SolStoreUtil.state.connection;
+        if (!connection || !params.provider) {
             throw new Error('Connection is not set');
         }
-        if (!this.appKit?.getCaipNetwork()) {
-            this.appKit?.setCaipNetwork(this.defaultCaipNetwork);
-        }
-        const balance = (await SolStoreUtil.state.connection.getBalance(new PublicKey(address))) /
-            SolConstantsUtil.LAMPORTS_PER_SOL;
-        this.appKit?.setBalance(balance.toString(), this.appKit?.getCaipNetwork()?.nativeCurrency.symbol, this.chainNamespace);
+        const transaction = await createSendTransaction({
+            provider: params.provider,
+            connection,
+            to: '11111111111111111111111111111111',
+            value: 1
+        });
+        const fee = await transaction.getEstimatedFee(connection);
+        return {
+            gas: BigInt(fee || 0)
+        };
     }
-    syncRequestedNetworks(caipNetworks) {
-        const uniqueChainNamespaces = Array.from(new Set(caipNetworks.map(caipNetwork => caipNetwork.chainNamespace)));
-        uniqueChainNamespaces.forEach(chainNamespace => {
-            this.appKit?.setRequestedCaipNetworks(caipNetworks.filter(caipNetwork => caipNetwork.chainNamespace === chainNamespace), chainNamespace);
+    async sendTransaction(params) {
+        const connection = SolStoreUtil.state.connection;
+        if (!connection || !params.address || !params.provider) {
+            throw new Error('Connection is not set');
+        }
+        const walletStandardProvider = params.provider;
+        const transaction = await createSendTransaction({
+            provider: walletStandardProvider,
+            connection,
+            to: params.to,
+            value: params.value
         });
+        const result = await walletStandardProvider.sendTransaction(transaction, connection);
+        await new Promise(resolve => {
+            const interval = setInterval(async () => {
+                const status = await connection.getSignatureStatus(result);
+                if (status?.value) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+        return {
+            hash: result
+        };
     }
-    getAuthSession() {
-        return this.authSession;
+    parseUnits() {
+        return 0n;
     }
-    async switchNetwork(caipNetwork) {
-        const connectedConnector = SafeLocalStorage.getItem(SafeLocalStorageKeys.CONNECTED_CONNECTOR);
-        const isConnectedWithAuth = connectedConnector === 'AUTH';
-        if (isConnectedWithAuth) {
-            await this.w3mFrameProvider?.switchNetwork(caipNetwork.caipNetworkId);
-            const user = await this.w3mFrameProvider?.getUser({
-                chainId: caipNetwork?.caipNetworkId
-            });
-            this.authSession = user;
-            if (user) {
-                const caipAddress = `${caipNetwork.caipNetworkId}:${user.address}`;
-                ProviderUtil.setProvider(this.chainNamespace, this.authProvider);
-                ProviderUtil.setProviderId(this.chainNamespace, 'walletConnect');
-                this.appKit?.setCaipAddress(caipAddress, this.chainNamespace);
-                this.syncAccount({
-                    address: user.address,
-                    caipNetwork
-                });
+    formatUnits() {
+        return '';
+    }
+    async connect(params) {
+        const { id, type, rpcUrl } = params;
+        const selectedProvider = this.connectors.find(c => c.id === id)?.provider;
+        if (!selectedProvider) {
+            throw new Error('Provider not found');
+        }
+        let address;
+        if (type === 'AUTH') {
+            const data = await this.authProvider?.connect();
+            if (!data) {
+                throw new Error('No address found');
             }
+            address = data;
         }
         else {
-            this.appKit?.setCaipNetwork(caipNetwork);
-            const address = this.appKit?.getAddress(this.chainNamespace);
-            await this.syncAccount({
-                address,
-                caipNetwork
-            });
+            address = await selectedProvider.connect();
         }
+        this.listenProviderEvents(selectedProvider);
+        SolStoreUtil.setConnection(new Connection(rpcUrl, 'confirmed'));
+        return {
+            address,
+            chainId: params.chainId,
+            provider: selectedProvider,
+            type: type,
+            id
+        };
     }
-    async syncNetwork(address) {
-        const caipNetwork = this.appKit?.getCaipNetwork(this.chainNamespace);
-        const connection = SolStoreUtil.state.connection;
-        if (!address || !caipNetwork || !connection) {
-            return;
+    async getBalance(params) {
+        const connection = new Connection(params.caipNetwork?.rpcUrls?.default?.http?.[0], this.connectionSettings);
+        const balance = await connection.getBalance(new PublicKey(params.address));
+        const formattedBalance = (balance / SolConstantsUtil.LAMPORTS_PER_SOL).toString();
+        if (!params.caipNetwork) {
+            throw new Error('caipNetwork is required');
         }
-        this.appKit?.setAddressExplorerUrl(caipNetwork.blockExplorers?.default.url
-            ? `${caipNetwork.blockExplorers.default.url}/account/${address}`
-            : undefined, this.chainNamespace);
-        await this.syncBalance(address);
+        return {
+            balance: formattedBalance,
+            symbol: params.caipNetwork?.nativeCurrency.symbol
+        };
     }
-    async setProvider(provider) {
-        try {
-            this.appKit?.setLoading(true);
-            const address = await provider.connect();
-            const caipNetworkId = SafeLocalStorage.getItem(SafeLocalStorageKeys.ACTIVE_CAIP_NETWORK_ID);
-            const connectionChain = provider.chains.find(chain => chain.caipNetworkId === caipNetworkId) || provider.chains[0];
-            if (connectionChain) {
-                const caipAddress = `${connectionChain.caipNetworkId}:${address}`;
-                this.appKit?.setCaipAddress(caipAddress, this.chainNamespace);
-                await this.switchNetwork(connectionChain);
-                ProviderUtil.setProvider(this.chainNamespace, provider);
-                this.provider = provider;
-                switch (provider.type) {
-                    case 'WALLET_CONNECT':
-                        ProviderUtil.setProviderId(this.chainNamespace, 'walletConnect');
-                        break;
-                    case 'AUTH':
-                        ProviderUtil.setProviderId(this.chainNamespace, 'w3mAuth');
-                        break;
-                    default:
-                        ProviderUtil.setProviderId(this.chainNamespace, 'injected');
-                }
-                SafeLocalStorage.setItem(SafeLocalStorageKeys.WALLET_ID, provider.name);
-                await this.appKit?.setApprovedCaipNetworksData(this.chainNamespace);
-                this.watchProvider(provider);
-            }
+    async switchNetwork(params) {
+        const { caipNetwork, provider, providerType } = params;
+        if (providerType === 'ID_AUTH') {
+            await provider.switchNetwork(caipNetwork.id);
+            const user = await provider.getUser({
+                chainId: caipNetwork.id
+            });
+            this.authSession = user;
+            this.emit('switchNetwork', { chainId: caipNetwork.id, address: user.address });
         }
-        finally {
-            this.appKit?.setLoading(false);
+        if (caipNetwork?.rpcUrls?.default?.http?.[0]) {
+            SolStoreUtil.setConnection(new Connection(caipNetwork.rpcUrls.default.http[0], this.connectionSettings));
         }
     }
-    watchProvider(provider) {
-        const rpcRequestHandler = (request) => {
-            if (!this.appKit) {
-                return;
-            }
-            if (W3mFrameHelpers.checkIfRequestExists(request)) {
-                if (!W3mFrameHelpers.checkIfRequestIsSafe(request)) {
-                    this.appKit?.handleUnsafeRPCRequest();
-                }
-            }
-            else {
-                this.appKit.open();
-                console.error(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_MESSAGE, {
-                    method: request.method
-                });
-                setTimeout(() => {
-                    this.appKit?.showErrorMessage(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_UI_MESSAGE);
-                }, 300);
-            }
+    listenProviderEvents(provider) {
+        const disconnectHandler = () => {
+            this.removeProviderListeners(provider);
+            this.emit('disconnect');
         };
-        const rpcSuccessHandler = (_response) => {
-            if (!this.appKit) {
-                return;
-            }
-            if (this.appKit.isTransactionStackEmpty()) {
-                this.appKit.close();
-            }
-            else {
-                this.appKit.popTransactionStack();
+        const accountsChangedHandler = (publicKey) => {
+            const address = publicKey.toBase58();
+            if (address) {
+                this.emit('accountChanged', { address });
             }
         };
-        const rpcErrorHandler = (_error) => {
-            if (!this.appKit) {
-                return;
-            }
-            if (this.appKit.isOpen()) {
-                if (this.appKit.isTransactionStackEmpty()) {
-                    this.appKit.close();
-                }
-                else {
-                    this.appKit.popTransactionStack(true);
-                }
-            }
+        provider.on('disconnect', disconnectHandler);
+        provider.on('accountsChanged', accountsChangedHandler);
+        provider.on('connect', accountsChangedHandler);
+        this.providerHandlers = {
+            disconnect: disconnectHandler,
+            accountsChanged: accountsChangedHandler
         };
-        function disconnectHandler(appKit) {
-            appKit?.resetAccount('solana');
-            SafeLocalStorage.removeItem(SafeLocalStorageKeys.WALLET_ID);
-            provider.removeListener('disconnect', disconnectHandler);
-            provider.removeListener('accountsChanged', accountsChangedHandler);
-            provider.removeListener('connect', accountsChangedHandler);
-            provider.removeListener('auth_rpcRequest', rpcRequestHandler);
-            provider.removeListener('auth_rpcSuccess', rpcSuccessHandler);
-            provider.removeListener('auth_rpcError', rpcErrorHandler);
-        }
-        function accountsChangedHandler(publicKey, appKit) {
-            const currentAccount = publicKey.toBase58();
-            const caipNetworkId = SafeLocalStorage.getItem(SafeLocalStorageKeys.ACTIVE_CAIP_NETWORK_ID);
-            const chainId = caipNetworkId?.split(':')[1];
-            if (currentAccount && chainId) {
-                appKit?.setCaipAddress(`solana:${chainId}:${currentAccount}`, 'solana');
-            }
-            else {
-                SafeLocalStorage.removeItem(SafeLocalStorageKeys.WALLET_ID);
-                appKit?.resetAccount('solana');
-            }
+    }
+    removeProviderListeners(provider) {
+        if (this.providerHandlers) {
+            provider.removeListener('disconnect', this.providerHandlers.disconnect);
+            provider.removeListener('accountsChanged', this.providerHandlers.accountsChanged);
+            provider.removeListener('connect', this.providerHandlers.accountsChanged);
+            this.providerHandlers = null;
         }
-        provider.on('disconnect', () => disconnectHandler(this.appKit));
-        provider.on('accountsChanged', (publicKey) => accountsChangedHandler(publicKey, this.appKit));
-        provider.on('connect', accountsChangedHandler);
-        provider.on('auth_rpcRequest', rpcRequestHandler);
-        provider.on('auth_rpcSuccess', rpcSuccessHandler);
-        provider.on('auth_rpcError', rpcErrorHandler);
     }
-    getSolanaWalletConnectProvider(provider) {
-        const walletConnectProvider = new WalletConnectProvider({
-            provider,
-            chains: this.caipNetworks,
-            getActiveChain: () => this.appKit?.getCaipNetwork()
+    async connectWalletConnect(onUri) {
+        const connector = this.connectors.find(c => c.type === 'WALLET_CONNECT');
+        const provider = connector?.provider;
+        if (!this.caipNetworks || !provider) {
+            throw new Error('UniversalAdapter:connectWalletConnect - caipNetworks or provider is undefined');
+        }
+        provider.on('display_uri', (uri) => {
+            onUri(uri);
         });
-        this.addProvider(walletConnectProvider);
-        return walletConnectProvider;
+        const namespaces = WcHelpersUtil.createNamespaces(this.caipNetworks);
+        await provider.connect({ optionalNamespaces: namespaces });
     }
-    initializeProviders(opts) {
-        if (CoreHelperUtil.isClient()) {
-            if (!opts.projectId) {
-                throw new Error('projectId is required for AuthProvider');
-            }
-            const getActiveChain = () => this.appKit?.getCaipNetwork(this.chainNamespace);
-            const emailEnabled = this.options?.features?.email === undefined
-                ? CoreConstantsUtil.DEFAULT_FEATURES.email
-                : this.options?.features?.email;
-            const socialsEnabled = this.options?.features?.socials
-                ? this.options?.features?.socials?.length > 0
-                : CoreConstantsUtil.DEFAULT_FEATURES.socials;
-            if (emailEnabled || socialsEnabled) {
-                this.w3mFrameProvider = W3mFrameProviderSingleton.getInstance({
-                    projectId: opts.projectId,
-                    chainId: withSolanaNamespace(this.appKit?.getCaipNetwork(this.chainNamespace)?.id),
-                    onTimeout: () => {
-                        AlertController.open(ErrorUtil.ALERT_ERRORS.SOCIALS_TIMEOUT, 'error');
-                    }
-                });
-                this.authProvider = new AuthProvider({
-                    getProvider: () => this.w3mFrameProvider,
-                    getActiveChain,
-                    getActiveNamespace: () => this.appKit?.getActiveChainNamespace(),
-                    getSession: () => this.getAuthSession(),
-                    setSession: (session) => {
-                        this.authSession = session;
-                    },
-                    chains: this.caipNetworks
-                });
-                this.addProvider(this.authProvider);
-            }
-            if ('coinbaseSolana' in window) {
-                this.addProvider(new CoinbaseWalletProvider({
-                    provider: window.coinbaseSolana,
-                    chains: this.caipNetworks,
-                    getActiveChain
-                }));
-            }
-            watchStandard(this.caipNetworks, getActiveChain, this.addProvider.bind(this));
+    async disconnect(params) {
+        if (!params.provider || !params.providerType) {
+            throw new Error('Provider or providerType not provided');
         }
+        await params.provider.disconnect();
+    }
+    async getProfile() {
+        return Promise.resolve({
+            profileName: undefined,
+            profileImage: undefined
+        });
     }
-    addProvider(...providers) {
-        const activeProviderName = SafeLocalStorage.getItem(SafeLocalStorageKeys.WALLET_ID);
-        const activeNamespace = this.appKit?.getActiveChainNamespace();
-        const isSolana = activeNamespace === this.chainNamespace;
-        for (const provider of providers) {
-            this.availableProviders = this.availableProviders.filter(p => p.name !== provider.name);
-            this.availableProviders.push(provider);
-            if (provider.name === activeProviderName && isSolana) {
-                this.setProvider(provider);
+    async syncConnection(params) {
+        const { id, rpcUrl } = params;
+        const connector = this.connectors.find(c => c.id === id);
+        const selectedProvider = connector?.provider;
+        if (!selectedProvider) {
+            throw new Error('Provider not found');
+        }
+        if (connector?.type === 'AUTH') {
+            const authProvider = selectedProvider;
+            const user = await authProvider.getUser({
+                chainId: Number(this.caipNetworks?.[0]?.id)
+            });
+            if (!user?.address) {
+                throw new Error('No address found');
             }
+            return {
+                address: user.address,
+                chainId: typeof user.chainId === 'string' ? Number(user.chainId.split(':')[1]) : 1,
+                provider: selectedProvider,
+                type: connector.type,
+                id
+            };
         }
-        this.syncConnectors();
+        const address = await selectedProvider.connect();
+        const chainId = this.caipNetworks?.[0]?.id || 1;
+        this.listenProviderEvents(selectedProvider);
+        SolStoreUtil.setConnection(new Connection(rpcUrl, 'confirmed'));
+        return {
+            address,
+            chainId,
+            provider: selectedProvider,
+            type: connector?.type,
+            id
+        };
     }
-    syncConnectors() {
-        const connectors = this.availableProviders.map(provider => ({
-            id: provider.name,
-            type: provider.type,
-            imageUrl: provider.icon,
-            name: provider.name,
-            provider: provider.type === 'AUTH' ? provider : undefined,
-            chain: CommonConstantsUtil.CHAIN.SOLANA
-        }));
-        this.appKit?.setConnectors(connectors);
+    getWalletConnectProvider(params) {
+        const walletConnectProvider = new WalletConnectProvider({
+            provider: params.provider,
+            chains: params.caipNetworks,
+            getActiveChain: () => params.activeCaipNetwork
+        });
+        return walletConnectProvider;
     }
 }
 //# sourceMappingURL=client.js.map