@reown/appkit-adapter-ethers 1.3.2 → 1.4.0

package/dist/esm/src/client.js

@@ -1,18 +1,21 @@
-import { SafeLocalStorage, SafeLocalStorageKeys } from '@reown/appkit-common';
-import { AccountController, ChainController, CoreHelperUtil, AlertController } from '@reown/appkit-core';
-import { EthersHelpersUtil } from '@reown/appkit-utils/ethers';
-import { W3mFrameHelpers, W3mFrameProvider, W3mFrameRpcConstants } from '@reown/appkit-wallet';
-import { ConstantsUtil as CoreConstantsUtil } from '@reown/appkit-core';
+import { AdapterBlueprint } from '@reown/appkit/adapters';
 import { ConstantsUtil as CommonConstantsUtil } from '@reown/appkit-common';
-import { CaipNetworksUtil, ConstantsUtil, ErrorUtil, HelpersUtil, PresetsUtil } from '@reown/appkit-utils';
+import {} from '@reown/appkit-core';
+import { ConstantsUtil, PresetsUtil } from '@reown/appkit-utils';
+import { EthersHelpersUtil } from '@reown/appkit-utils/ethers';
+import { WcConstantsUtil, WcHelpersUtil } from '@reown/appkit';
 import UniversalProvider from '@walletconnect/universal-provider';
-import { WcConstantsUtil } from '@reown/appkit';
-import { EthersMethods } from './utils/EthersMethods.js';
 import { formatEther, InfuraProvider, JsonRpcProvider } from 'ethers';
-import { ProviderUtil } from '@reown/appkit/store';
 import { CoinbaseWalletSDK } from '@coinbase/wallet-sdk';
-import { W3mFrameProviderSingleton } from '@reown/appkit/auth-provider';
-export class EthersAdapter {
+import { EthersMethods } from './utils/EthersMethods.js';
+import { ProviderUtil } from '@reown/appkit/store';
+export class EthersAdapter extends AdapterBlueprint {
+    constructor() {
+        super({});
+        this.adapterType = 'ethers';
+        this.providerHandlers = null;
+        this.namespace = CommonConstantsUtil.CHAIN.EVM;
+    }
     createEthersConfig(options) {
         if (!options.metadata) {
             return undefined;
@@ -59,472 +62,275 @@ export class EthersAdapter {
         providers.EIP6963 = options.enableEIP6963 !== false;
         return providers;
     }
-    constructor() {
-        this.appKit = undefined;
-        this.EIP6963Providers = [];
-        this.options = undefined;
-        this.caipNetworks = [];
-        this.chainNamespace = CommonConstantsUtil.CHAIN.EVM;
-        this.siweControllerClient = this.options?.siweConfig;
-        this.tokens = HelpersUtil.getCaipTokens(this.options?.tokens);
-        this.defaultCaipNetwork = undefined;
-        this.adapterType = 'ethers';
-        this.providerHandlers = null;
-        ChainController.subscribeKey('activeCaipNetwork', val => {
-            const caipAddress = this.appKit?.getCaipAddress(this.chainNamespace);
-            const isEVMAddress = caipAddress?.startsWith('eip155:');
-            const isEVMNetwork = val?.chainNamespace === this.chainNamespace;
-            if (isEVMAddress && isEVMNetwork && caipAddress) {
-                this.syncBalance(CoreHelperUtil.getPlainAddress(caipAddress), val);
-                this.syncAccount({
-                    address: CoreHelperUtil.getPlainAddress(caipAddress),
-                    caipNetwork: val
-                });
-            }
-        });
-        ChainController.subscribeKey('activeCaipAddress', val => {
-            const isEVMAddress = val?.startsWith('eip155:');
-            const caipNetwork = ChainController.state.activeCaipNetwork;
-            const isEVMNetwork = caipNetwork?.chainNamespace === this.chainNamespace;
-            if (isEVMAddress) {
-                if (isEVMNetwork) {
-                    this.syncBalance(CoreHelperUtil.getPlainAddress(val), caipNetwork);
-                }
-                this.syncAccount({ address: CoreHelperUtil.getPlainAddress(val) });
-            }
-        });
-        AccountController.subscribeKey('shouldUpdateToAddress', newAddress => {
-            const isEVMAddress = newAddress?.startsWith('0x');
-            if (isEVMAddress) {
-                this.syncAccount({ address: newAddress });
-            }
-        }, this.chainNamespace);
-    }
-    construct(appKit, options) {
-        this.appKit = appKit;
-        this.options = options;
-        this.caipNetworks = options.networks;
-        this.defaultCaipNetwork = options.defaultNetwork
-            ? CaipNetworksUtil.extendCaipNetwork(options.defaultNetwork, {
-                customNetworkImageUrls: options.chainImages,
-                projectId: options.projectId
-            })
-            : this.caipNetworks[0];
-        this.tokens = HelpersUtil.getCaipTokens(options.tokens);
-        this.ethersConfig = this.createEthersConfig(options);
-        this.networkControllerClient = {
-            switchCaipNetwork: async (caipNetwork) => {
-                if (caipNetwork?.id) {
-                    try {
-                        await this.switchNetwork(caipNetwork);
-                    }
-                    catch (error) {
-                        throw new Error('networkControllerClient:switchCaipNetwork - unable to switch chain');
-                    }
-                }
-            },
-            getApprovedCaipNetworksData: async () => this.getApprovedCaipNetworksData()
-        };
-        this.connectionControllerClient = {
-            connectWalletConnect: async (onUri) => {
-                await this.appKit?.universalAdapter?.connectionControllerClient?.connectWalletConnect?.(onUri);
-            },
-            connectExternal: async ({ id, info, provider }) => {
-                this.appKit?.setClientId(null);
-                const connectorConfig = {
-                    [ConstantsUtil.INJECTED_CONNECTOR_ID]: {
-                        getProvider: () => this.ethersConfig?.injected,
-                        providerType: 'injected'
-                    },
-                    [ConstantsUtil.EIP6963_CONNECTOR_ID]: {
-                        getProvider: () => provider,
-                        providerType: 'eip6963'
-                    },
-                    [ConstantsUtil.COINBASE_SDK_CONNECTOR_ID]: {
-                        getProvider: () => this.ethersConfig?.coinbase,
-                        providerType: 'coinbaseWalletSDK'
-                    },
-                    [ConstantsUtil.AUTH_CONNECTOR_ID]: {
-                        getProvider: () => this.authProvider,
-                        providerType: 'w3mAuth'
-                    }
-                };
-                const selectedConnector = connectorConfig[id];
-                if (!selectedConnector) {
-                    throw new Error(`Unsupported connector ID: ${id}`);
-                }
-                const selectedProvider = selectedConnector.getProvider();
-                if (!selectedProvider) {
-                    throw new Error(`Provider for connector ${id} is undefined`);
-                }
-                try {
-                    if (selectedProvider && id !== ConstantsUtil.AUTH_CONNECTOR_ID) {
-                        await selectedProvider.request({ method: 'eth_requestAccounts' });
-                    }
-                    await this.setProvider(selectedProvider, selectedConnector.providerType, info?.name);
-                }
-                catch (error) {
-                    if (id === ConstantsUtil.COINBASE_SDK_CONNECTOR_ID) {
-                        throw new Error(error.message);
-                    }
-                }
-            },
-            checkInstalled: (ids) => {
-                if (!ids) {
-                    return Boolean(window.ethereum);
-                }
-                if (this.ethersConfig?.injected) {
-                    if (!window?.ethereum) {
-                        return false;
-                    }
-                }
-                return ids.some(id => Boolean(window.ethereum?.[String(id)]));
-            },
-            disconnect: async () => {
-                const provider = ProviderUtil.getProvider('eip155');
-                const providerId = ProviderUtil.state.providerIds['eip155'];
-                this.appKit?.setClientId(null);
-                if (this.options?.siweConfig?.options?.signOutOnDisconnect) {
-                    const { SIWEController } = await import('@reown/appkit-siwe');
-                    await SIWEController.signOut();
-                }
-                const disconnectConfig = {
-                    [ConstantsUtil.WALLET_CONNECT_CONNECTOR_ID]: async () => await this.appKit?.universalAdapter?.connectionControllerClient?.disconnect(),
-                    coinbaseWalletSDK: async () => {
-                        if (provider && 'disconnect' in provider) {
-                            await provider.disconnect();
-                        }
-                    },
-                    [ConstantsUtil.AUTH_CONNECTOR_ID]: async () => {
-                        await this.authProvider?.disconnect();
-                    },
-                    [ConstantsUtil.EIP6963_CONNECTOR_ID]: async () => {
-                        if (provider) {
-                            await this.revokeProviderPermissions(provider);
-                        }
-                    },
-                    [ConstantsUtil.INJECTED_CONNECTOR_ID]: async () => {
-                        if (provider) {
-                            ;
-                            provider.emit('disconnect');
-                            await this.revokeProviderPermissions(provider);
-                        }
-                    }
-                };
-                const disconnectFunction = disconnectConfig[providerId];
-                if (disconnectFunction) {
-                    await disconnectFunction();
-                }
-                else {
-                    console.warn(`No disconnect function found for provider type: ${providerId}`);
-                }
-                SafeLocalStorage.removeItem(SafeLocalStorageKeys.WALLET_ID);
-                this.appKit?.resetAccount(this.chainNamespace);
-                this.removeListeners(provider);
-            },
-            signMessage: async (message) => {
-                const provider = ProviderUtil.getProvider(this.chainNamespace);
-                const caipAddress = ChainController.state.activeCaipAddress;
-                const address = CoreHelperUtil.getPlainAddress(caipAddress);
-                if (!address) {
-                    throw new Error('Address is undefined');
-                }
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                return await EthersMethods.signMessage(message, provider, address);
-            },
-            parseUnits: EthersMethods.parseUnits,
-            formatUnits: EthersMethods.formatUnits,
-            estimateGas: async (data) => {
-                if (data.chainNamespace && data.chainNamespace !== 'eip155') {
-                    throw new Error(`Invalid chain namespace - Expected eip155, got ${data.chainNamespace}`);
-                }
-                const provider = ProviderUtil.getProvider('eip155');
-                const caipAddress = ChainController.state.activeCaipAddress;
-                const address = CoreHelperUtil.getPlainAddress(caipAddress);
-                const caipNetwork = this.appKit?.getCaipNetwork();
-                if (!address) {
-                    throw new Error('Address is undefined');
-                }
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                return await EthersMethods.estimateGas(data, provider, address, Number(caipNetwork?.id));
-            },
-            getCapabilities: async (params) => {
-                const provider = ProviderUtil.getProvider(CommonConstantsUtil.CHAIN.EVM);
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                const walletCapabilitiesString = provider.session?.sessionProperties?.['capabilities'];
-                if (walletCapabilitiesString) {
-                    const walletCapabilities = EthersMethods.parseWalletCapabilities(walletCapabilitiesString);
-                    const accountCapabilities = walletCapabilities[params];
-                    if (accountCapabilities) {
-                        return accountCapabilities;
-                    }
-                }
-                return await provider.request({ method: 'wallet_getCapabilities', params: [params] });
-            },
-            grantPermissions: async (params) => {
-                const provider = ProviderUtil.getProvider(CommonConstantsUtil.CHAIN.EVM);
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                return await provider.request({ method: 'wallet_grantPermissions', params });
-            },
-            revokePermissions: async (session) => {
-                const provider = ProviderUtil.getProvider(CommonConstantsUtil.CHAIN.EVM);
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                return await provider.request({ method: 'wallet_revokePermissions', params: [session] });
-            },
-            sendTransaction: async (data) => {
-                if (data.chainNamespace && data.chainNamespace !== 'eip155') {
-                    throw new Error(`Invalid chain namespace - Expected eip155, got ${data.chainNamespace}`);
-                }
-                const provider = ProviderUtil.getProvider('eip155');
-                const caipAddress = ChainController.state.activeCaipAddress;
-                const address = CoreHelperUtil.getPlainAddress(caipAddress);
-                const caipNetwork = this.appKit?.getCaipNetwork();
-                if (!address) {
-                    throw new Error('Address is undefined');
-                }
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                return await EthersMethods.sendTransaction(data, provider, address, Number(caipNetwork?.id));
-            },
-            writeContract: async (data) => {
-                const provider = ProviderUtil.getProvider('eip155');
-                const caipAddress = ChainController.state.activeCaipAddress;
-                const address = CoreHelperUtil.getPlainAddress(caipAddress);
-                const caipNetwork = this.appKit?.getCaipNetwork();
-                if (!address) {
-                    throw new Error('Address is undefined');
-                }
-                if (!provider) {
-                    throw new Error('Provider is undefined');
-                }
-                return await EthersMethods.writeContract(data, provider, address, Number(caipNetwork?.id));
-            },
-            getEnsAddress: async (value) => {
-                if (this.appKit) {
-                    return await EthersMethods.getEnsAddress(value, this.appKit);
-                }
-                return false;
-            },
-            getEnsAvatar: async (value) => {
-                const caipNetwork = this.appKit?.getCaipNetwork();
-                return await EthersMethods.getEnsAvatar(value, Number(caipNetwork?.id));
-            }
-        };
-        ChainController.state.chains.set(this.chainNamespace, {
-            chainNamespace: this.chainNamespace,
-            connectionControllerClient: this.connectionControllerClient,
-            networkControllerClient: this.networkControllerClient,
-            adapterType: this.adapterType,
-            caipNetworks: this.caipNetworks
-        });
-        if (this.ethersConfig) {
-            this.syncConnectors(this.ethersConfig);
-        }
-        if (typeof window !== 'undefined') {
-            this.listenConnectors(true);
-        }
-        this.appKit?.setEIP6963Enabled(this.ethersConfig?.EIP6963);
-        const emailEnabled = options.features?.email === undefined
-            ? CoreConstantsUtil.DEFAULT_FEATURES.email
-            : options.features?.email;
-        const socialsEnabled = options.features?.socials
-            ? options.features?.socials?.length > 0
-            : CoreConstantsUtil.DEFAULT_FEATURES.socials;
-        if (emailEnabled || socialsEnabled) {
-            this.syncAuthConnector(this.options.projectId);
-        }
-        if (this.ethersConfig) {
-            this.checkActiveProviders(this.ethersConfig);
-        }
-        this.syncRequestedNetworks(this.caipNetworks);
+    async signMessage(params) {
+        const { message, address, provider } = params;
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        try {
+            const signature = await EthersMethods.signMessage(message, provider, address);
+            return { signature };
+        }
+        catch (error) {
+            throw new Error('EthersAdapter:signMessage - Sign message failed');
+        }
     }
-    subscribeState(callback) {
-        return this.appKit?.subscribeState(state => callback(state));
+    async sendTransaction(params) {
+        if (!params.provider) {
+            throw new Error('Provider is undefined');
+        }
+        const tx = await EthersMethods.sendTransaction({
+            value: params.value,
+            to: params.to,
+            data: params.data,
+            gas: params.gas,
+            gasPrice: params.gasPrice,
+            address: params.address
+        }, params.provider, params.address, Number(params.caipNetwork?.id));
+        return { hash: tx };
     }
-    async disconnect() {
-        await this.connectionControllerClient?.disconnect();
+    async writeContract(params) {
+        if (!params.provider) {
+            throw new Error('Provider is undefined');
+        }
+        const result = await EthersMethods.writeContract({
+            abi: params.abi,
+            method: params.method,
+            fromAddress: params.caipAddress,
+            receiverAddress: params.receiverAddress,
+            tokenAmount: params.tokenAmount,
+            tokenAddress: params.tokenAddress
+        }, params.provider, params.caipAddress, Number(params.caipNetwork?.id));
+        return { hash: result };
     }
-    async revokeProviderPermissions(provider) {
+    async estimateGas(params) {
+        const { provider, caipNetwork, address } = params;
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
         try {
-            const permissions = await provider.request({
-                method: 'wallet_getPermissions'
-            });
-            const ethAccountsPermission = permissions.find(permission => permission.parentCapability === 'eth_accounts');
-            if (ethAccountsPermission) {
-                await provider.request({
-                    method: 'wallet_revokePermissions',
-                    params: [{ eth_accounts: {} }]
-                });
-            }
+            const result = await EthersMethods.estimateGas({
+                data: params.data,
+                to: params.to,
+                address: address
+            }, provider, address, Number(caipNetwork?.id));
+            return { gas: result };
         }
         catch (error) {
-            console.info('Could not revoke permissions from wallet. Disconnecting...', error);
+            throw new Error('EthersAdapter:estimateGas - Estimate gas failed');
         }
     }
-    getApprovedCaipNetworksData() {
-        return new Promise(resolve => {
-            const walletId = SafeLocalStorage.getItem(SafeLocalStorageKeys.WALLET_ID);
-            if (!walletId) {
-                throw new Error('No wallet id found to get approved networks data');
-            }
-            const providerConfigs = {
-                [ConstantsUtil.AUTH_CONNECTOR_ID]: {
-                    supportsAllNetworks: true,
-                    approvedCaipNetworkIds: PresetsUtil.WalletConnectRpcChainIds.map(id => `${ConstantsUtil.EIP155}:${id}`)
-                }
-            };
-            const networkData = providerConfigs[walletId];
-            if (networkData) {
-                resolve(networkData);
-            }
-            else {
-                resolve({
-                    supportsAllNetworks: true,
-                    approvedCaipNetworkIds: []
+    async getEnsAddress(params) {
+        const { name, caipNetwork } = params;
+        if (caipNetwork) {
+            const result = await EthersMethods.getEnsAddress(name, caipNetwork);
+            return { address: result };
+        }
+        return { address: '' };
+    }
+    parseUnits(params) {
+        return EthersMethods.parseUnits(params.value, params.decimals);
+    }
+    formatUnits(params) {
+        return EthersMethods.formatUnits(params.value, params.decimals);
+    }
+    async syncConnection(params) {
+        const { id, chainId } = params;
+        const connector = this.connectors.find(c => c.id === id);
+        const selectedProvider = connector?.provider;
+        if (!selectedProvider) {
+            throw new Error('Provider not found');
+        }
+        const accounts = await selectedProvider.request({
+            method: 'eth_requestAccounts'
+        });
+        this.listenProviderEvents(selectedProvider);
+        if (!accounts[0]) {
+            throw new Error('No accounts found');
+        }
+        if (!connector?.type) {
+            throw new Error('Connector type not found');
+        }
+        return {
+            address: accounts[0],
+            chainId: Number(chainId),
+            provider: selectedProvider,
+            type: connector.type,
+            id
+        };
+    }
+    syncConnectors(options) {
+        this.ethersConfig = this.createEthersConfig(options);
+        if (this.ethersConfig?.EIP6963) {
+            this.listenInjectedConnector(true);
+        }
+        const connectors = Object.keys(this.ethersConfig || {}).filter(key => key !== 'metadata' && key !== 'EIP6963');
+        connectors.forEach(connector => {
+            const key = connector === 'coinbase' ? 'coinbaseWalletSDK' : connector;
+            if (this.namespace) {
+                this.addConnector({
+                    id: connector,
+                    explorerId: PresetsUtil.ConnectorExplorerIds[key],
+                    imageUrl: options?.connectorImages?.[key],
+                    name: PresetsUtil.ConnectorNamesMap[key],
+                    imageId: PresetsUtil.ConnectorImageIds[key],
+                    type: PresetsUtil.ConnectorTypesMap[key] ?? 'EXTERNAL',
+                    info: { rdns: key },
+                    chain: this.namespace,
+                    chains: [],
+                    provider: this.ethersConfig?.[connector]
                 });
             }
         });
     }
-    checkActiveProviders(config) {
-        const walletId = SafeLocalStorage.getItem(SafeLocalStorageKeys.WALLET_ID);
-        const walletName = SafeLocalStorage.getItem(SafeLocalStorageKeys.WALLET_NAME);
-        if (!walletId) {
-            return;
-        }
-        const providerConfigs = {
-            [ConstantsUtil.INJECTED_CONNECTOR_ID]: {
-                provider: config.injected
-            },
-            [ConstantsUtil.COINBASE_SDK_CONNECTOR_ID]: {
-                provider: config.coinbase
-            },
-            [ConstantsUtil.EIP6963_CONNECTOR_ID]: {
-                provider: this.EIP6963Providers.find(p => p.info.name === walletName)?.provider
+    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);
+        });
+        const namespaces = WcHelpersUtil.createNamespaces(this.caipNetworks);
+        await provider.connect({ optionalNamespaces: namespaces });
+    }
+    eip6963EventHandler(event) {
+        if (event.detail) {
+            const { info, provider } = event.detail;
+            const existingConnector = this.connectors?.find(c => c.name === info?.name);
+            const coinbaseConnector = this.connectors?.find(c => c.id === ConstantsUtil.COINBASE_SDK_CONNECTOR_ID);
+            const isCoinbaseDuplicated = coinbaseConnector &&
+                event.detail.info?.rdns ===
+                    ConstantsUtil.CONNECTOR_RDNS_MAP[ConstantsUtil.COINBASE_SDK_CONNECTOR_ID];
+            if (!existingConnector && !isCoinbaseDuplicated) {
+                const type = PresetsUtil.ConnectorTypesMap[ConstantsUtil.EIP6963_CONNECTOR_ID];
+                if (type && this.namespace) {
+                    this.addConnector({
+                        id: info?.rdns || '',
+                        type,
+                        imageUrl: info?.icon,
+                        name: info?.name,
+                        provider,
+                        info,
+                        chain: this.namespace,
+                        chains: []
+                    });
+                }
             }
-        };
-        const activeConfig = providerConfigs[walletId];
-        if (activeConfig?.provider) {
-            this.setProvider(activeConfig.provider, walletId);
-            this.setupProviderListeners(activeConfig.provider, walletId);
         }
     }
-    async setProvider(provider, providerId, name) {
-        if (providerId === 'w3mAuth') {
-            this.setAuthProvider();
+    listenInjectedConnector(enableEIP6963) {
+        if (typeof window !== 'undefined' && enableEIP6963) {
+            const handler = this.eip6963EventHandler.bind(this);
+            window.addEventListener(ConstantsUtil.EIP6963_ANNOUNCE_EVENT, handler);
+            window.dispatchEvent(new Event(ConstantsUtil.EIP6963_REQUEST_EVENT));
+        }
+    }
+    async connect({ id, type, chainId }) {
+        const connector = this.connectors.find(c => c.id === id);
+        const selectedProvider = connector?.provider;
+        if (!selectedProvider) {
+            throw new Error('Provider not found');
+        }
+        let accounts = [];
+        if (type === 'AUTH') {
+            const { address } = await selectedProvider.connect({
+                chainId
+            });
+            accounts = [address];
         }
         else {
-            const walletId = providerId;
-            SafeLocalStorage.setItem(SafeLocalStorageKeys.WALLET_ID, walletId);
-            if (name) {
-                SafeLocalStorage.setItem(SafeLocalStorageKeys.WALLET_NAME, name);
-            }
-            if (provider) {
-                const { addresses, chainId } = await EthersHelpersUtil.getUserInfo(provider);
-                const firstAddress = addresses?.[0];
-                const caipNetwork = this.caipNetworks.find(c => c.id === chainId) ?? this.caipNetworks[0];
-                const caipAddress = `${this.chainNamespace}:${caipNetwork?.id}:${firstAddress}`;
-                if (firstAddress && caipNetwork) {
-                    this.appKit?.setCaipNetwork(caipNetwork);
-                    this.appKit?.setCaipAddress(caipAddress, this.chainNamespace);
-                    ProviderUtil.setProviderId('eip155', providerId);
-                    ProviderUtil.setProvider('eip155', provider);
-                    this.appKit?.setStatus('connected', this.chainNamespace);
-                    this.appKit?.setAllAccounts(addresses.map(address => ({ address, type: 'eoa' })), this.chainNamespace);
-                }
-            }
+            accounts = await selectedProvider.request({
+                method: 'eth_requestAccounts'
+            });
+            this.listenProviderEvents(selectedProvider);
+        }
+        return {
+            address: accounts[0],
+            chainId: Number(chainId),
+            provider: selectedProvider,
+            type: type,
+            id
+        };
+    }
+    async reconnect(params) {
+        const { id, chainId } = params;
+        const connector = this.connectors.find(c => c.id === id);
+        if (connector && connector.type === 'AUTH' && chainId) {
+            await connector.provider.connect({ chainId });
         }
     }
-    async setAuthProvider() {
-        SafeLocalStorage.setItem(SafeLocalStorageKeys.WALLET_ID, ConstantsUtil.AUTH_CONNECTOR_ID);
-        if (this.authProvider) {
-            this.appKit?.setLoading(true);
-            const { address, chainId, smartAccountDeployed, preferredAccountType, accounts = [] } = await this.authProvider.connect({
-                chainId: Number(this.appKit?.getCaipNetwork()?.id || this.caipNetworks[0]?.id)
-            });
-            const { smartAccountEnabledNetworks } = await this.authProvider.getSmartAccountEnabledNetworks();
-            this.appKit?.setSmartAccountEnabledNetworks(smartAccountEnabledNetworks, this.chainNamespace);
-            if (address && chainId) {
-                this.appKit?.setAllAccounts(accounts.length > 0
-                    ? accounts
-                    : [{ address, type: preferredAccountType }], this.chainNamespace);
-                this.appKit?.setStatus('connected', this.chainNamespace);
-                this.appKit?.setCaipAddress(`${this.chainNamespace}:${chainId}:${address}`, this.chainNamespace);
-                this.appKit?.setPreferredAccountType(preferredAccountType, this.chainNamespace);
-                this.appKit?.setSmartAccountDeployed(Boolean(smartAccountDeployed), this.chainNamespace);
-                ProviderUtil.setProvider('eip155', this.authProvider);
-                ProviderUtil.setProviderId('eip155', ConstantsUtil.AUTH_CONNECTOR_ID);
-                this.setupProviderListeners(this.authProvider, 'w3mAuth');
-                this.watchModal();
-            }
-            this.appKit?.setLoading(false);
+    async disconnect(params) {
+        if (!params.provider || !params.providerType) {
+            throw new Error('Provider or providerType not provided');
+        }
+        switch (params.providerType) {
+            case 'WALLET_CONNECT':
+                if (params.provider.session) {
+                    ;
+                    params.provider.disconnect();
+                }
+                break;
+            case 'AUTH':
+                await params.provider.disconnect();
+                break;
+            case 'ANNOUNCED':
+            case 'EXTERNAL':
+                await this.revokeProviderPermissions(params.provider);
+                break;
+            default:
+                throw new Error('Unsupported provider type');
         }
     }
-    watchModal() {
-        if (this.authProvider) {
-            this.subscribeState(val => {
-                if (!val.open) {
-                    this.authProvider?.rejectRpcRequests();
-                }
+    async getBalance(params) {
+        const caipNetwork = this.caipNetworks?.find((c) => c.id === params.chainId);
+        if (caipNetwork) {
+            const jsonRpcProvider = new JsonRpcProvider(caipNetwork.rpcUrls.default.http[0], {
+                chainId: caipNetwork.id,
+                name: caipNetwork.name
             });
+            const balance = await jsonRpcProvider.getBalance(params.address);
+            const formattedBalance = formatEther(balance);
+            return { balance: formattedBalance, symbol: caipNetwork.nativeCurrency.symbol };
         }
+        return { balance: '', symbol: '' };
     }
-    setupProviderListeners(provider, providerId) {
+    async getProfile(params) {
+        if (params.chainId === 1) {
+            const ensProvider = new InfuraProvider('mainnet');
+            const name = await ensProvider.lookupAddress(params.address);
+            const avatar = await ensProvider.getAvatar(params.address);
+            return { profileName: name || undefined, profileImage: avatar || undefined };
+        }
+        return { profileName: undefined, profileImage: undefined };
+    }
+    listenProviderEvents(provider) {
         const disconnectHandler = () => {
-            SafeLocalStorage.removeItem(SafeLocalStorageKeys.WALLET_ID);
-            this.removeListeners(provider);
+            this.removeProviderListeners(provider);
+            this.emit('disconnect');
         };
         const accountsChangedHandler = (accounts) => {
-            const currentAccount = accounts?.[0];
-            if (currentAccount) {
-                const chainId = this.appKit?.getCaipNetwork()?.id;
-                const caipAddress = `${this.chainNamespace}:${chainId}:${currentAccount}`;
-                this.appKit?.setCaipAddress(caipAddress, this.chainNamespace);
-                if (providerId === ConstantsUtil.EIP6963_CONNECTOR_ID) {
-                    this.appKit?.setAllAccounts(accounts.map(address => ({ address, type: 'eoa' })), this.chainNamespace);
-                }
-            }
-            else {
-                if (providerId === ConstantsUtil.EIP6963_CONNECTOR_ID) {
-                    this.appKit?.setAllAccounts([], this.chainNamespace);
-                }
-                SafeLocalStorage.removeItem(SafeLocalStorageKeys.WALLET_ID);
-                this.appKit?.resetAccount(this.chainNamespace);
+            if (accounts.length > 0) {
+                this.emit('accountChanged', {
+                    address: accounts[0]
+                });
             }
         };
         const chainChangedHandler = (chainId) => {
             const chainIdNumber = typeof chainId === 'string' ? EthersHelpersUtil.hexStringToNumber(chainId) : Number(chainId);
-            const caipNetwork = this.caipNetworks.find(c => c.id === chainIdNumber);
-            const currentCaipNetwork = this.appKit?.getCaipNetwork();
-            if (!currentCaipNetwork || currentCaipNetwork?.id !== caipNetwork?.id) {
-                this.appKit?.setCaipNetwork(caipNetwork);
-            }
+            this.emit('switchNetwork', { chainId: chainIdNumber });
         };
-        if (providerId === ConstantsUtil.AUTH_CONNECTOR_ID) {
-            this.setupAuthListeners(provider);
-        }
-        else {
-            provider.on('disconnect', disconnectHandler);
-            provider.on('accountsChanged', accountsChangedHandler);
-            provider.on('chainChanged', chainChangedHandler);
-        }
+        provider.on('disconnect', disconnectHandler);
+        provider.on('accountsChanged', accountsChangedHandler);
+        provider.on('chainChanged', chainChangedHandler);
         this.providerHandlers = {
             disconnect: disconnectHandler,
             accountsChanged: accountsChangedHandler,
             chainChanged: chainChangedHandler
         };
     }
-    removeListeners(provider) {
+    removeProviderListeners(provider) {
         if (this.providerHandlers) {
             provider.removeListener('disconnect', this.providerHandlers.disconnect);
             provider.removeListener('accountsChanged', this.providerHandlers.accountsChanged);
@@ -532,212 +338,20 @@ export class EthersAdapter {
             this.providerHandlers = null;
         }
     }
-    setupAuthListeners(authProvider) {
-        authProvider.onRpcRequest(request => {
-            if (W3mFrameHelpers.checkIfRequestExists(request)) {
-                if (!W3mFrameHelpers.checkIfRequestIsSafe(request)) {
-                    this.appKit?.handleUnsafeRPCRequest();
-                }
-            }
-            else {
-                this.handleInvalidAuthRequest();
-            }
-        });
-        authProvider.onRpcError(() => this.handleAuthRpcError());
-        authProvider.onRpcSuccess((_, request) => this.handleAuthRpcSuccess(_, request));
-        authProvider.onNotConnected(() => this.handleAuthNotConnected());
-        authProvider.onConnect(({ preferredAccountType }) => this.handleAuthIsConnected(preferredAccountType));
-        authProvider.onSetPreferredAccount(({ address, type }) => {
-            if (address) {
-                this.handleAuthSetPreferredAccount(address, type);
-            }
-        });
-    }
-    handleInvalidAuthRequest() {
-        this.appKit?.open();
-        setTimeout(() => {
-            this.appKit?.showErrorMessage(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_UI_MESSAGE);
-        }, 300);
-    }
-    handleAuthRpcError() {
-        if (this.appKit?.isOpen()) {
-            if (this.appKit?.isTransactionStackEmpty()) {
-                this.appKit?.close();
-            }
-            else {
-                this.appKit?.popTransactionStack(true);
-            }
-        }
-    }
-    handleAuthRpcSuccess(_, request) {
-        const isSafeRequest = W3mFrameHelpers.checkIfRequestIsSafe(request);
-        if (isSafeRequest) {
-            return;
-        }
-        if (this.appKit?.isTransactionStackEmpty()) {
-            this.appKit?.close();
-        }
-        else {
-            this.appKit?.popTransactionStack();
-        }
-    }
-    handleAuthNotConnected() {
-        this.appKit?.setCaipAddress(undefined, this.chainNamespace);
-    }
-    handleAuthIsConnected(preferredAccountType) {
-        const activeNamespace = this.appKit?.getActiveChainNamespace();
-        if (activeNamespace !== this.chainNamespace) {
-            return;
-        }
-        this.appKit?.setPreferredAccountType(preferredAccountType, this.chainNamespace);
-    }
-    handleAuthSetPreferredAccount(address, type) {
-        if (!address) {
-            return;
-        }
-        this.appKit?.setLoading(true);
-        const chainId = this.appKit?.getCaipNetwork()?.id;
-        this.appKit?.setCaipAddress(`${this.chainNamespace}:${chainId}:${address}`, this.chainNamespace);
-        this.appKit?.setStatus('connected', this.chainNamespace);
-        this.appKit?.setPreferredAccountType(type, this.chainNamespace);
-        this.syncAccount({
-            address: address
-        }).then(() => this.appKit?.setLoading(false));
-        this.appKit?.setLoading(false);
-    }
-    async syncReownName(address) {
-        try {
-            const registeredWcNames = await this.appKit?.getReownName(address);
-            if (registeredWcNames?.[0]) {
-                const wcName = registeredWcNames[0];
-                this.appKit?.setProfileName(wcName.name, this.chainNamespace);
-            }
-            else {
-                this.appKit?.setProfileName(null, this.chainNamespace);
-            }
-        }
-        catch {
-            this.appKit?.setProfileName(null, this.chainNamespace);
-        }
-    }
-    async syncAccount({ address, caipNetwork }) {
-        const currentCaipNetwork = caipNetwork || this.appKit?.getCaipNetwork();
-        const preferredAccountType = this.appKit?.getPreferredAccountType();
-        const isEipNetwork = currentCaipNetwork?.chainNamespace === CommonConstantsUtil.CHAIN.EVM;
-        const caipNetworkId = currentCaipNetwork?.id;
-        if (address) {
-            if (isEipNetwork) {
-                this.appKit?.setPreferredAccountType(preferredAccountType, this.chainNamespace);
-                this.appKit?.setCaipAddress(`${this.chainNamespace}:${caipNetworkId}:${address}`, this.chainNamespace);
-                this.syncConnectedWalletInfo();
-                if (currentCaipNetwork?.blockExplorers?.default.url) {
-                    this.appKit?.setAddressExplorerUrl(`${currentCaipNetwork.blockExplorers.default.url}/address/${address}`, this.chainNamespace);
-                }
-                await Promise.all([
-                    this.syncProfile(address),
-                    this.appKit?.setApprovedCaipNetworksData(this.chainNamespace)
-                ]);
-            }
-        }
-        else {
-            this.appKit?.resetWcConnection();
-            this.appKit?.resetNetwork(this.chainNamespace);
-            this.appKit?.setAllAccounts([], this.chainNamespace);
-        }
-    }
-    async syncProfile(address) {
-        const caipNetwork = this.appKit?.getCaipNetwork();
-        try {
-            const identity = await this.appKit?.fetchIdentity({
-                address
+    async switchNetwork(params) {
+        const { caipNetwork, provider, providerType } = params;
+        if (providerType === 'WALLET_CONNECT') {
+            ;
+            provider.setDefaultChain(String(`eip155:${String(caipNetwork.id)}`));
+        }
+        else if (providerType === 'AUTH') {
+            const authProvider = provider;
+            await authProvider.switchNetwork(caipNetwork.id);
+            await authProvider.connect({
+                chainId: caipNetwork.id
             });
-            const name = identity?.name;
-            const avatar = identity?.avatar;
-            this.appKit?.setProfileName(name, this.chainNamespace);
-            this.appKit?.setProfileImage(avatar, this.chainNamespace);
-            if (!name) {
-                await this.syncReownName(address);
-            }
-        }
-        catch {
-            if (caipNetwork?.id === 1) {
-                const ensProvider = new InfuraProvider('mainnet');
-                const name = await ensProvider.lookupAddress(address);
-                const avatar = await ensProvider.getAvatar(address);
-                if (name) {
-                    this.appKit?.setProfileName(name, this.chainNamespace);
-                }
-                else {
-                    await this.syncReownName(address);
-                }
-                if (avatar) {
-                    this.appKit?.setProfileImage(avatar, this.chainNamespace);
-                }
-            }
-            else {
-                await this.syncReownName(address);
-                this.appKit?.setProfileImage(null, this.chainNamespace);
-            }
         }
-    }
-    async syncBalance(address, caipNetwork) {
-        const isExistingNetwork = this.appKit
-            ?.getCaipNetworks(caipNetwork.chainNamespace)
-            .find(network => network.id === caipNetwork.id);
-        const isEVMNetwork = caipNetwork.chainNamespace === CommonConstantsUtil.CHAIN.EVM;
-        if (caipNetwork && isExistingNetwork && isEVMNetwork) {
-            const jsonRpcProvider = new JsonRpcProvider(caipNetwork.rpcUrls.default.http[0], {
-                chainId: caipNetwork.id,
-                name: caipNetwork.name
-            });
-            if (jsonRpcProvider) {
-                const balance = await jsonRpcProvider.getBalance(address);
-                const formattedBalance = formatEther(balance);
-                this.appKit?.setBalance(formattedBalance, caipNetwork.nativeCurrency.symbol, this.chainNamespace);
-            }
-        }
-    }
-    syncConnectedWalletInfo() {
-        const currentActiveWallet = SafeLocalStorage.getItem(SafeLocalStorageKeys.WALLET_ID);
-        const providerType = ProviderUtil.state.providerIds['eip155'];
-        if (providerType === ConstantsUtil.EIP6963_CONNECTOR_ID) {
-            if (currentActiveWallet) {
-                const currentProvider = this.EIP6963Providers.find(provider => provider.info.name === currentActiveWallet);
-                if (currentProvider) {
-                    this.appKit?.setConnectedWalletInfo({ ...currentProvider.info }, this.chainNamespace);
-                }
-            }
-        }
-        else if (providerType === ConstantsUtil.WALLET_CONNECT_CONNECTOR_ID) {
-            const provider = ProviderUtil.getProvider('eip155');
-            if (provider?.session) {
-                this.appKit?.setConnectedWalletInfo({
-                    ...provider.session.peer.metadata,
-                    name: provider.session.peer.metadata.name,
-                    icon: provider.session.peer.metadata.icons?.[0]
-                }, this.chainNamespace);
-            }
-        }
-        else if (providerType === ConstantsUtil.COINBASE_SDK_CONNECTOR_ID) {
-            const connector = this.appKit
-                ?.getConnectors()
-                .find(c => c.id === ConstantsUtil.COINBASE_SDK_CONNECTOR_ID);
-            this.appKit?.setConnectedWalletInfo({ name: 'Coinbase Wallet', icon: this.appKit?.getConnectorImage(connector) }, this.chainNamespace);
-        }
-        else if (currentActiveWallet) {
-            this.appKit?.setConnectedWalletInfo({ name: currentActiveWallet }, this.chainNamespace);
-        }
-    }
-    syncRequestedNetworks(caipNetworks) {
-        const uniqueChainNamespaces = [
-            ...new Set(caipNetworks.map(caipNetwork => caipNetwork.chainNamespace))
-        ];
-        uniqueChainNamespaces.forEach(chainNamespace => {
-            this.appKit?.setRequestedCaipNetworks(caipNetworks.filter(caipNetwork => caipNetwork.chainNamespace === chainNamespace), chainNamespace);
-        });
-    }
-    async switchNetwork(caipNetwork) {
-        async function requestSwitchNetwork(provider) {
+        else {
             try {
                 await provider.request({
                     method: 'wallet_switchEthereumChain',
@@ -751,147 +365,62 @@ export class EthersAdapter {
                         WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID) {
                     await EthersHelpersUtil.addEthereumChain(provider, caipNetwork);
                 }
-                else {
+                else if (providerType === 'ANNOUNCED' ||
+                    providerType === 'EXTERNAL' ||
+                    providerType === 'INJECTED') {
                     throw new Error('Chain is not supported');
                 }
             }
         }
-        const provider = ProviderUtil.getProvider('eip155');
-        const providerType = ProviderUtil.state.providerIds['eip155'];
-        if (provider) {
-            switch (providerType) {
-                case ConstantsUtil.WALLET_CONNECT_CONNECTOR_ID:
-                    this.appKit?.universalAdapter?.networkControllerClient.switchCaipNetwork(caipNetwork);
-                    break;
-                case ConstantsUtil.INJECTED_CONNECTOR_ID:
-                case ConstantsUtil.EIP6963_CONNECTOR_ID:
-                case ConstantsUtil.COINBASE_SDK_CONNECTOR_ID:
-                    if (provider) {
-                        await requestSwitchNetwork(provider);
-                    }
-                    break;
-                case ConstantsUtil.AUTH_CONNECTOR_ID:
-                    if (this.authProvider) {
-                        try {
-                            this.appKit?.setLoading(true);
-                            const { chainId } = await this.authProvider.switchNetwork(caipNetwork.id);
-                            const { address, preferredAccountType } = await this.authProvider.connect({
-                                chainId: caipNetwork.id
-                            });
-                            const caipAddress = `${this.chainNamespace}:${chainId}:${address}`;
-                            this.appKit?.setCaipNetwork(caipNetwork);
-                            this.appKit?.setCaipAddress(caipAddress, this.chainNamespace);
-                            this.appKit?.setPreferredAccountType(preferredAccountType, this.chainNamespace);
-                            await this.syncAccount({ address: address });
-                            this.appKit?.setLoading(false);
-                        }
-                        catch {
-                            throw new Error('Switching chain failed');
-                        }
-                        finally {
-                            this.appKit?.setLoading(false);
-                        }
-                    }
-                    break;
-                default:
-                    throw new Error('Unsupported provider type');
-            }
-        }
     }
-    syncConnectors(config) {
-        const w3mConnectors = [];
-        if (config.injected) {
-            const injectedConnectorType = PresetsUtil.ConnectorTypesMap[ConstantsUtil.INJECTED_CONNECTOR_ID];
-            if (injectedConnectorType) {
-                w3mConnectors.push({
-                    id: ConstantsUtil.INJECTED_CONNECTOR_ID,
-                    explorerId: PresetsUtil.ConnectorExplorerIds[ConstantsUtil.INJECTED_CONNECTOR_ID],
-                    imageId: PresetsUtil.ConnectorImageIds[ConstantsUtil.INJECTED_CONNECTOR_ID],
-                    imageUrl: this.options?.connectorImages?.[ConstantsUtil.INJECTED_CONNECTOR_ID],
-                    name: PresetsUtil.ConnectorNamesMap[ConstantsUtil.INJECTED_CONNECTOR_ID],
-                    type: injectedConnectorType,
-                    chain: this.chainNamespace
+    getWalletConnectProvider() {
+        return this.connectors.find(c => c.type === 'WALLET_CONNECT')?.provider;
+    }
+    async revokeProviderPermissions(provider) {
+        try {
+            const permissions = await provider.request({
+                method: 'wallet_getPermissions'
+            });
+            const ethAccountsPermission = permissions.find(permission => permission.parentCapability === 'eth_accounts');
+            if (ethAccountsPermission) {
+                await provider.request({
+                    method: 'wallet_revokePermissions',
+                    params: [{ eth_accounts: {} }]
                 });
             }
         }
-        if (config.coinbase) {
-            w3mConnectors.push({
-                id: ConstantsUtil.COINBASE_SDK_CONNECTOR_ID,
-                explorerId: PresetsUtil.ConnectorExplorerIds[ConstantsUtil.COINBASE_SDK_CONNECTOR_ID],
-                imageId: PresetsUtil.ConnectorImageIds[ConstantsUtil.COINBASE_SDK_CONNECTOR_ID],
-                imageUrl: this.options?.connectorImages?.[ConstantsUtil.COINBASE_SDK_CONNECTOR_ID],
-                name: PresetsUtil.ConnectorNamesMap[ConstantsUtil.COINBASE_SDK_CONNECTOR_ID],
-                type: 'EXTERNAL',
-                chain: this.chainNamespace
-            });
+        catch (error) {
+            console.info('Could not revoke permissions from wallet. Disconnecting...', error);
         }
-        this.appKit?.setConnectors(w3mConnectors);
     }
-    async syncAuthConnector(projectId, bypassWindowCheck = false) {
-        if (bypassWindowCheck || typeof window !== 'undefined') {
-            this.authProvider = W3mFrameProviderSingleton.getInstance({
-                projectId,
-                onTimeout: () => {
-                    AlertController.open(ErrorUtil.ALERT_ERRORS.SOCIALS_TIMEOUT, 'error');
-                }
-            });
-            this.appKit?.addConnector({
-                id: ConstantsUtil.AUTH_CONNECTOR_ID,
-                type: 'AUTH',
-                name: 'Auth',
-                provider: this.authProvider,
-                chain: this.chainNamespace
-            });
-            this.appKit?.setLoading(true);
-            const isLoginEmailUsed = this.authProvider.getLoginEmailUsed();
-            this.appKit?.setLoading(isLoginEmailUsed);
-            if (isLoginEmailUsed) {
-                const { isConnected } = await this.authProvider.isConnected();
-                if (isConnected) {
-                    await this.setAuthProvider();
-                }
-                else {
-                    this.appKit?.setLoading(false);
-                }
+    async getCapabilities(params) {
+        const provider = ProviderUtil.getProvider(CommonConstantsUtil.CHAIN.EVM);
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const walletCapabilitiesString = provider.session?.sessionProperties?.['capabilities'];
+        if (walletCapabilitiesString) {
+            const walletCapabilities = EthersMethods.parseWalletCapabilities(walletCapabilitiesString);
+            const accountCapabilities = walletCapabilities[params];
+            if (accountCapabilities) {
+                return accountCapabilities;
             }
         }
+        return await provider.request({ method: 'wallet_getCapabilities', params: [params] });
     }
-    eip6963EventHandler(event) {
-        if (event.detail) {
-            const { info, provider } = event.detail;
-            const connectors = this.appKit?.getConnectors();
-            const existingConnector = connectors?.find(c => c.name === info.name);
-            const coinbaseConnector = connectors?.find(c => c.id === ConstantsUtil.COINBASE_SDK_CONNECTOR_ID);
-            const isCoinbaseDuplicated = coinbaseConnector &&
-                event.detail.info.rdns ===
-                    ConstantsUtil.CONNECTOR_RDNS_MAP[ConstantsUtil.COINBASE_SDK_CONNECTOR_ID];
-            if (!existingConnector && !isCoinbaseDuplicated) {
-                const type = PresetsUtil.ConnectorTypesMap[ConstantsUtil.EIP6963_CONNECTOR_ID];
-                if (type) {
-                    this.appKit?.addConnector({
-                        id: ConstantsUtil.EIP6963_CONNECTOR_ID,
-                        type,
-                        imageUrl: info.icon ?? this.options?.connectorImages?.[ConstantsUtil.EIP6963_CONNECTOR_ID],
-                        name: info.name,
-                        provider,
-                        info,
-                        chain: this.chainNamespace
-                    });
-                    const eip6963ProviderObj = {
-                        provider,
-                        info
-                    };
-                    this.EIP6963Providers.push(eip6963ProviderObj);
-                }
-            }
+    async grantPermissions(params) {
+        const provider = ProviderUtil.getProvider(CommonConstantsUtil.CHAIN.EVM);
+        if (!provider) {
+            throw new Error('Provider is undefined');
         }
+        return await provider.request({ method: 'wallet_grantPermissions', params });
     }
-    listenConnectors(enableEIP6963) {
-        if (typeof window !== 'undefined' && enableEIP6963) {
-            const handler = this.eip6963EventHandler.bind(this);
-            window.addEventListener(ConstantsUtil.EIP6963_ANNOUNCE_EVENT, handler);
-            window.dispatchEvent(new Event(ConstantsUtil.EIP6963_REQUEST_EVENT));
+    async revokePermissions(params) {
+        const provider = ProviderUtil.getProvider(CommonConstantsUtil.CHAIN.EVM);
+        if (!provider) {
+            throw new Error('Provider is undefined');
         }
+        return await provider.request({ method: 'wallet_revokePermissions', params: [params] });
     }
 }
 //# sourceMappingURL=client.js.map