@reown/appkit-adapter-ethers 1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0 → 1.8.15-viem-upgrade.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reown/appkit-adapter-ethers",
-  "version": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
+  "version": "1.8.15-viem-upgrade.0",
   "sideEffects": false,
   "type": "module",
   "main": "./dist/esm/src/index.js",
@@ -11,15 +11,15 @@
     "README.md"
   ],
   "dependencies": {
-    "@walletconnect/universal-provider": "2.23.0",
+    "@walletconnect/universal-provider": "2.23.1",
     "valtio": "2.1.7",
-    "@reown/appkit": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
-    "@reown/appkit-common": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
-    "@reown/appkit-controllers": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
-    "@reown/appkit-polyfills": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
-    "@reown/appkit-scaffold-ui": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
-    "@reown/appkit-utils": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0",
-    "@reown/appkit-wallet": "1.8.15-e95f0d61c614677233e13ea9f055d3f75fcdba81.0"
+    "@reown/appkit": "1.8.15-viem-upgrade.0",
+    "@reown/appkit-common": "1.8.15-viem-upgrade.0",
+    "@reown/appkit-controllers": "1.8.15-viem-upgrade.0",
+    "@reown/appkit-polyfills": "1.8.15-viem-upgrade.0",
+    "@reown/appkit-scaffold-ui": "1.8.15-viem-upgrade.0",
+    "@reown/appkit-utils": "1.8.15-viem-upgrade.0",
+    "@reown/appkit-wallet": "1.8.15-viem-upgrade.0"
   },
   "peerDependencies": {
     "@ethersproject/sha2": "5.8.0",
@@ -27,7 +27,7 @@
   },
   "devDependencies": {
     "@vitest/coverage-v8": "2.1.9",
-    "@walletconnect/types": "2.23.0",
+    "@walletconnect/types": "2.23.1",
     "vitest": "2.1.9"
   },
   "author": "Reown (https://discord.gg/reown)",

package/dist/esm/src/client.js

@@ -1,612 +0,0 @@
-import UniversalProvider from '@walletconnect/universal-provider';
-import { JsonRpcProvider, formatEther, getAddress } from 'ethers';
-import { WcConstantsUtil } from '@reown/appkit';
-import { ConstantsUtil as CommonConstantsUtil, ErrorUtil, ParseUtil, UserRejectedRequestError } from '@reown/appkit-common';
-import { ConstantsUtil, PresetsUtil } from '@reown/appkit-common';
-import { AssetController, ChainController, ConnectorUtil, CoreHelperUtil, OptionsController, SIWXUtil, StorageUtil, WcHelpersUtil, getPreferredAccountType } from '@reown/appkit-controllers';
-import { AdapterBlueprint, ProviderController, WalletConnectConnector } from '@reown/appkit-controllers';
-import { HelpersUtil } from '@reown/appkit-utils';
-import { BaseProvider, EthersHelpersUtil, InjectedProvider, SafeProvider } from '@reown/appkit-utils/ethers';
-import { EthersMethods } from './utils/EthersMethods.js';
-export class EthersAdapter extends AdapterBlueprint {
-    constructor() {
-        super({
-            adapterType: CommonConstantsUtil.ADAPTER_TYPES.ETHERS,
-            namespace: CommonConstantsUtil.CHAIN.EVM
-        });
-        this.balancePromises = {};
-        this.ethersProviders = {};
-    }
-    async createEthersConfig() {
-        const { metadata, enableCoinbase, enableInjected, enableEIP6963 } = OptionsController.state;
-        if (!metadata) {
-            return undefined;
-        }
-        if (enableInjected !== false) {
-            const injectedProvider = new InjectedProvider();
-            await injectedProvider.initialize();
-            this.ethersProviders.injected = injectedProvider;
-        }
-        if (enableCoinbase !== false) {
-            this.ethersProviders.baseAccount = new BaseProvider();
-        }
-        if (CoreHelperUtil.isSafeApp()) {
-            const safeProvider = new SafeProvider();
-            await safeProvider.initialize();
-            this.ethersProviders.safe = safeProvider;
-        }
-        return {
-            ...this.ethersProviders,
-            EIP6963: enableEIP6963 !== false,
-            metadata
-        };
-    }
-    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');
-        }
-    }
-    async sendTransaction(params) {
-        if (!params.provider) {
-            throw new Error('Provider is undefined');
-        }
-        const address = ChainController.getAccountData(CommonConstantsUtil.CHAIN.EVM)?.address;
-        if (!address) {
-            throw new Error('Address is undefined');
-        }
-        const tx = await EthersMethods.sendTransaction({
-            value: Number.isNaN(Number(params.value)) ? BigInt(0) : BigInt(params.value),
-            to: params.to,
-            data: params.data ? params.data : '0x',
-            gas: params.gas ? BigInt(params.gas) : undefined,
-            gasPrice: params.gasPrice ? BigInt(params.gasPrice) : undefined,
-            address: address
-        }, params.provider, address, Number(params.caipNetwork?.id));
-        return { hash: tx };
-    }
-    async writeContract(params) {
-        if (!params.provider) {
-            throw new Error('Provider is undefined');
-        }
-        const { address } = ParseUtil.parseCaipAddress(params.caipAddress);
-        const result = await EthersMethods.writeContract(params, params.provider, address, Number(params.caipNetwork?.id));
-        return { hash: result };
-    }
-    async estimateGas(params) {
-        const { provider, caipNetwork, address } = params;
-        if (!provider) {
-            throw new Error('Provider is undefined');
-        }
-        try {
-            const result = await EthersMethods.estimateGas({
-                data: params.data,
-                to: params.to,
-                address: address
-            }, provider, address, Number(caipNetwork?.id));
-            return { gas: result };
-        }
-        catch (error) {
-            throw new Error('EthersAdapter:estimateGas - Estimate gas failed');
-        }
-    }
-    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'
-        });
-        const requestChainId = await selectedProvider.request({
-            method: 'eth_chainId'
-        });
-        this.listenProviderEvents(id, selectedProvider);
-        if (!accounts[0]) {
-            throw new Error('No accounts found');
-        }
-        if (!connector?.type) {
-            throw new Error('Connector type not found');
-        }
-        return {
-            address: this.toChecksummedAddress(accounts[0]),
-            chainId: Number(requestChainId) || Number(chainId),
-            provider: selectedProvider,
-            type: connector.type,
-            id
-        };
-    }
-    async syncConnectors() {
-        this.ethersConfig = await this.createEthersConfig();
-        if (this.ethersConfig?.EIP6963) {
-            this.listenInjectedConnector(true);
-        }
-        const connectors = Object.keys(this.ethersConfig || {}).filter(key => key !== 'metadata' && key !== 'EIP6963');
-        const connectorPromises = connectors.map(async (connector) => {
-            const isInjectedConnector = connector === CommonConstantsUtil.CONNECTOR_ID.INJECTED;
-            if (this.namespace) {
-                const provider = this.ethersProviders[connector];
-                this.addConnector({
-                    id: connector,
-                    explorerId: PresetsUtil.ConnectorExplorerIds[connector],
-                    imageUrl: AssetController.state.connectorImages?.[connector],
-                    name: PresetsUtil.ConnectorNamesMap[connector] || 'Unknown',
-                    imageId: PresetsUtil.ConnectorImageIds[connector],
-                    type: PresetsUtil.ConnectorTypesMap[connector] ?? 'EXTERNAL',
-                    info: isInjectedConnector ? undefined : { rdns: connector },
-                    chain: this.namespace,
-                    chains: [],
-                    provider: (await provider?.getProvider())
-                });
-            }
-        });
-        await Promise.all(connectorPromises);
-    }
-    async disconnectAll() {
-        const connections = await Promise.all(this.connections.map(async (connection) => {
-            const connector = this.connectors.find(c => HelpersUtil.isLowerCaseMatch(c.id, connection.connectorId));
-            if (!connector) {
-                throw new Error('Connector not found');
-            }
-            await this.disconnect({
-                id: connector.id
-            });
-            return connection;
-        }));
-        return { connections };
-    }
-    async syncConnections({ connectToFirstConnector }) {
-        const caipNetworks = this.getCaipNetworks();
-        await Promise.all(this.connectors
-            .filter(c => {
-            const { hasDisconnected, hasConnected } = HelpersUtil.getConnectorStorageInfo(c.id, this.namespace);
-            return !hasDisconnected && hasConnected;
-        })
-            .map(async (connector) => {
-            if (connector.id === CommonConstantsUtil.CONNECTOR_ID.WALLET_CONNECT) {
-                const accounts = WcHelpersUtil.getWalletConnectAccounts(this.universalProvider, this.namespace);
-                const caipNetwork = caipNetworks.find(n => n.chainNamespace === this.namespace &&
-                    n.id.toString() === accounts[0]?.chainId?.toString());
-                if (accounts.length > 0) {
-                    this.addConnection({
-                        connectorId: connector.id,
-                        accounts: accounts.map(account => ({ address: account.address })),
-                        caipNetwork
-                    });
-                }
-            }
-            else {
-                const { accounts, chainId } = await ConnectorUtil.fetchProviderData(connector);
-                if (accounts.length > 0 && chainId) {
-                    const caipNetwork = caipNetworks.find(n => n.chainNamespace === this.namespace && n.id.toString() === chainId.toString());
-                    this.addConnection({
-                        connectorId: connector.id,
-                        accounts: accounts.map(address => ({ address })),
-                        caipNetwork
-                    });
-                    if (connector.provider &&
-                        connector.id !== CommonConstantsUtil.CONNECTOR_ID.AUTH &&
-                        connector.id !== CommonConstantsUtil.CONNECTOR_ID.WALLET_CONNECT) {
-                        this.listenProviderEvents(connector.id, connector.provider);
-                    }
-                }
-            }
-        }));
-        if (connectToFirstConnector) {
-            this.emitFirstAvailableConnection();
-        }
-    }
-    async setUniversalProvider(universalProvider) {
-        this.universalProvider = universalProvider;
-        const wcConnectorId = CommonConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
-        WcHelpersUtil.listenWcProvider({
-            universalProvider,
-            namespace: CommonConstantsUtil.CHAIN.EVM,
-            onConnect: accounts => this.onConnect(accounts, wcConnectorId),
-            onDisconnect: () => this.onDisconnect(wcConnectorId),
-            onAccountsChanged: accounts => this.onAccountsChanged(accounts, wcConnectorId, false),
-            onChainChanged: chainId => this.onChainChanged(chainId, wcConnectorId)
-        });
-        this.addConnector(new WalletConnectConnector({
-            provider: universalProvider,
-            caipNetworks: this.getCaipNetworks(),
-            namespace: CommonConstantsUtil.CHAIN.EVM
-        }));
-        return Promise.resolve();
-    }
-    eip6963EventHandler(event) {
-        if (event.detail) {
-            const { info, provider } = event.detail;
-            const existingConnector = this.connectors?.find(c => c.name === info?.name);
-            if (!existingConnector) {
-                const type = PresetsUtil.ConnectorTypesMap[CommonConstantsUtil.CONNECTOR_ID.EIP6963];
-                const id = info?.rdns || info?.name || info?.uuid;
-                if (type && this.namespace && id) {
-                    this.addConnector({
-                        id,
-                        type,
-                        explorerId: PresetsUtil.ConnectorExplorerIds[info.rdns || ''] ??
-                            PresetsUtil.ConnectorExplorerIds[info.name || ''],
-                        imageUrl: info?.icon,
-                        name: info?.name || 'Unknown',
-                        provider,
-                        info,
-                        chain: this.namespace,
-                        chains: []
-                    });
-                }
-            }
-        }
-    }
-    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, address, type, chainId, socialUri }) {
-        try {
-            const connector = this.connectors.find(c => HelpersUtil.isLowerCaseMatch(c.id, id));
-            if (!connector) {
-                throw new Error('Connector not found');
-            }
-            const connection = this.getConnection({
-                address,
-                connectorId: id,
-                connections: this.connections,
-                connectors: this.connectors
-            });
-            if (connection) {
-                const caipNetwork = connection.caipNetwork;
-                if (!caipNetwork) {
-                    throw new Error('EthersAdapter:connect - could not find the caipNetwork to connect');
-                }
-                if (connection.account) {
-                    this.emit('accountChanged', {
-                        address: this.toChecksummedAddress(connection.account.address),
-                        chainId: caipNetwork.id,
-                        connector
-                    });
-                    return {
-                        address: this.toChecksummedAddress(connection.account.address),
-                        chainId: caipNetwork.id,
-                        provider: connector.provider,
-                        type: connector.type,
-                        id
-                    };
-                }
-            }
-            let selectedProvider = connector?.provider;
-            const ethersProvider = this.ethersProviders[connector.id];
-            if (ethersProvider) {
-                await ethersProvider.initialize();
-                selectedProvider = (await ethersProvider.getProvider());
-            }
-            if (!selectedProvider) {
-                throw new Error('Provider not found');
-            }
-            connector.provider = selectedProvider;
-            let accounts = [];
-            let requestChainId = undefined;
-            if (type === ConstantsUtil.CONNECTOR_TYPE_AUTH) {
-                const { address: _address, accounts: authAccounts } = await SIWXUtil.authConnectorAuthenticate({
-                    authConnector: selectedProvider,
-                    chainNamespace: CommonConstantsUtil.CHAIN.EVM,
-                    chainId,
-                    socialUri,
-                    preferredAccountType: getPreferredAccountType('eip155')
-                });
-                const caipNetwork = this.getCaipNetworks().find(n => n.id.toString() === chainId?.toString());
-                accounts = [_address];
-                this.addConnection({
-                    connectorId: id,
-                    accounts: authAccounts
-                        ? authAccounts.map(account => ({ address: account.address }))
-                        : accounts.map(account => ({ address: account })),
-                    caipNetwork,
-                    auth: {
-                        name: StorageUtil.getConnectedSocialProvider(),
-                        username: StorageUtil.getConnectedSocialUsername()
-                    }
-                });
-                this.emit('accountChanged', {
-                    address: this.toChecksummedAddress(accounts[0]),
-                    chainId: Number(chainId),
-                    connector
-                });
-            }
-            else {
-                accounts = await selectedProvider.request({
-                    method: 'eth_requestAccounts'
-                });
-                requestChainId = await selectedProvider.request({
-                    method: 'eth_chainId'
-                });
-                const caipNetwork = this.getCaipNetworks().find(n => n.id.toString() === chainId?.toString());
-                if (requestChainId !== chainId) {
-                    if (!caipNetwork) {
-                        throw new Error('EthersAdapter:connect - could not find the caipNetwork to switch');
-                    }
-                    try {
-                        await selectedProvider?.request({
-                            method: 'wallet_switchEthereumChain',
-                            params: [{ chainId: EthersHelpersUtil.numberToHexString(caipNetwork.id) }]
-                        });
-                    }
-                    catch (error) {
-                        throw new Error('EthersAdapter:connect - Switch network failed');
-                    }
-                }
-                this.emit('accountChanged', {
-                    address: this.toChecksummedAddress(accounts[0]),
-                    chainId: Number(chainId),
-                    connector
-                });
-                this.addConnection({
-                    connectorId: id,
-                    accounts: accounts.map(account => ({ address: account })),
-                    caipNetwork
-                });
-                if (connector.id !== CommonConstantsUtil.CONNECTOR_ID.WALLET_CONNECT) {
-                    this.listenProviderEvents(id, selectedProvider);
-                }
-            }
-            return {
-                address: this.toChecksummedAddress(accounts[0]),
-                chainId: Number(chainId),
-                provider: selectedProvider,
-                type: type,
-                id
-            };
-        }
-        catch (err) {
-            if (ErrorUtil.isUserRejectedRequestError(err)) {
-                throw new UserRejectedRequestError(err);
-            }
-            throw err;
-        }
-    }
-    async reconnect(params) {
-        const { id, chainId } = params;
-        const connector = this.connectors.find(c => c.id === id);
-        if (connector && connector.type === 'AUTH' && chainId) {
-            await SIWXUtil.authConnectorAuthenticate({
-                authConnector: connector.provider,
-                chainNamespace: CommonConstantsUtil.CHAIN.EVM,
-                chainId,
-                preferredAccountType: getPreferredAccountType('eip155')
-            });
-        }
-    }
-    async getAccounts(params) {
-        const connector = this.connectors.find(c => c.id === params.id);
-        const selectedProvider = connector?.provider;
-        if (!selectedProvider || !connector) {
-            throw new Error('Provider not found');
-        }
-        const connection = this.getConnection({
-            connectorId: params.id,
-            connections: this.connections,
-            connectors: this.connectors
-        });
-        if (connection) {
-            return {
-                accounts: connection.accounts.map(({ address }) => CoreHelperUtil.createAccount(CommonConstantsUtil.CHAIN.EVM, address, 'eoa'))
-            };
-        }
-        if (params.id === CommonConstantsUtil.CONNECTOR_ID.AUTH) {
-            const provider = connector['provider'];
-            if (!provider.user) {
-                return { accounts: [] };
-            }
-            const { accounts, address } = provider.user;
-            return Promise.resolve({
-                accounts: (accounts || [{ address, type: 'eoa' }]).map(account => CoreHelperUtil.createAccount(CommonConstantsUtil.CHAIN.EVM, account.address, account.type))
-            });
-        }
-        const accounts = await selectedProvider.request({
-            method: 'eth_requestAccounts'
-        });
-        return {
-            accounts: accounts.map(account => CoreHelperUtil.createAccount(CommonConstantsUtil.CHAIN.EVM, account, 'eoa'))
-        };
-    }
-    async disconnect(params) {
-        if (params.id) {
-            const connector = this.connectors.find(c => HelpersUtil.isLowerCaseMatch(c.id, params.id));
-            if (!connector) {
-                throw new Error('Connector not found');
-            }
-            const connection = this.getConnection({
-                connectorId: params.id,
-                connections: this.connections,
-                connectors: this.connectors
-            });
-            switch (connector.type) {
-                case ConstantsUtil.CONNECTOR_TYPE_WALLET_CONNECT:
-                    if (connector.provider.session) {
-                        ;
-                        connector.provider.disconnect();
-                    }
-                    break;
-                case ConstantsUtil.CONNECTOR_TYPE_AUTH:
-                    await connector.provider?.disconnect();
-                    break;
-                case ConstantsUtil.CONNECTOR_TYPE_ANNOUNCED:
-                case ConstantsUtil.CONNECTOR_TYPE_EXTERNAL:
-                    await this.revokeProviderPermissions(connector.provider);
-                    break;
-                default:
-                    throw new Error('Unsupported provider type');
-            }
-            if (connector.id) {
-                this.removeProviderListeners(connector.id);
-                this.deleteConnection(connector.id);
-            }
-            if (this.connections.length === 0) {
-                this.emit('disconnect');
-            }
-            else {
-                this.emitFirstAvailableConnection();
-            }
-            return { connections: connection ? [connection] : [] };
-        }
-        return this.disconnectAll();
-    }
-    async getBalance(params) {
-        const address = params.address;
-        const caipNetwork = this.getCaipNetworks().find(network => network.id.toString() === params.chainId?.toString());
-        if (!address) {
-            return Promise.resolve({ balance: '0.00', symbol: 'ETH' });
-        }
-        if (caipNetwork && caipNetwork.chainNamespace === CommonConstantsUtil.CHAIN.EVM) {
-            const caipAddress = `${caipNetwork.caipNetworkId}:${address}`;
-            const cachedPromise = this.balancePromises[caipAddress];
-            if (cachedPromise) {
-                return cachedPromise;
-            }
-            const cachedBalance = StorageUtil.getNativeBalanceCacheForCaipAddress(caipAddress);
-            if (cachedBalance) {
-                return { balance: cachedBalance.balance, symbol: cachedBalance.symbol };
-            }
-            const jsonRpcProvider = new JsonRpcProvider(caipNetwork.rpcUrls.default.http[0], {
-                chainId: caipNetwork.id,
-                name: caipNetwork.name
-            });
-            if (jsonRpcProvider) {
-                try {
-                    this.balancePromises[caipAddress] = new Promise(async (resolve) => {
-                        try {
-                            const balance = await jsonRpcProvider.getBalance(address);
-                            const formattedBalance = formatEther(balance);
-                            StorageUtil.updateNativeBalanceCache({
-                                caipAddress,
-                                balance: formattedBalance,
-                                symbol: caipNetwork.nativeCurrency.symbol,
-                                timestamp: Date.now()
-                            });
-                            resolve({ balance: formattedBalance, symbol: caipNetwork.nativeCurrency.symbol });
-                        }
-                        catch (error) {
-                            resolve({ balance: '0.00', symbol: 'ETH' });
-                        }
-                    }).finally(() => {
-                        delete this.balancePromises[caipAddress];
-                    });
-                    return this.balancePromises[caipAddress] || { balance: '0.00', symbol: 'ETH' };
-                }
-                catch (error) {
-                    return { balance: '0.00', symbol: 'ETH' };
-                }
-            }
-        }
-        return { balance: '0.00', symbol: 'ETH' };
-    }
-    async switchNetwork(params) {
-        const { caipNetwork } = params;
-        const providerType = ProviderController.getProviderId(caipNetwork.chainNamespace);
-        const provider = ProviderController.getProvider(caipNetwork.chainNamespace);
-        if (providerType === 'AUTH' || providerType === 'WALLET_CONNECT') {
-            await super.switchNetwork(params);
-            return;
-        }
-        if (!provider) {
-            throw new Error('Provider not found');
-        }
-        try {
-            await provider?.request({
-                method: 'wallet_switchEthereumChain',
-                params: [{ chainId: EthersHelpersUtil.numberToHexString(caipNetwork.id) }]
-            });
-        }
-        catch (switchError) {
-            if (switchError.code === WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID ||
-                switchError.code === WcConstantsUtil.ERROR_INVALID_CHAIN_ID ||
-                switchError.code === WcConstantsUtil.ERROR_CODE_DEFAULT ||
-                switchError?.data?.originalError?.code === WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID) {
-                await EthersHelpersUtil.addEthereumChain(provider, caipNetwork);
-            }
-            else if (providerType === 'ANNOUNCED' ||
-                providerType === 'EXTERNAL' ||
-                providerType === 'INJECTED') {
-                throw new Error('Chain is not supported');
-            }
-        }
-    }
-    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: {} }]
-                });
-            }
-        }
-        catch (error) {
-            console.info('Could not revoke permissions from wallet. Disconnecting...', error);
-        }
-    }
-    async getCapabilities(params) {
-        const provider = ProviderController.getProvider(CommonConstantsUtil.CHAIN.EVM);
-        if (!provider) {
-            throw new Error('Provider is undefined');
-        }
-        return await provider.request({ method: 'wallet_getCapabilities', params: [params] });
-    }
-    async grantPermissions(params) {
-        const provider = ProviderController.getProvider(CommonConstantsUtil.CHAIN.EVM);
-        if (!provider) {
-            throw new Error('Provider is undefined');
-        }
-        return await provider.request({ method: 'wallet_grantPermissions', params });
-    }
-    async revokePermissions(params) {
-        const provider = ProviderController.getProvider(CommonConstantsUtil.CHAIN.EVM);
-        if (!provider) {
-            throw new Error('Provider is undefined');
-        }
-        return await provider.request({ method: 'wallet_revokePermissions', params: [params] });
-    }
-    async walletGetAssets(params) {
-        const provider = ProviderController.getProvider(CommonConstantsUtil.CHAIN.EVM);
-        if (!provider) {
-            throw new Error('Provider is undefined');
-        }
-        return await provider.request({
-            method: 'wallet_getAssets',
-            params: [params]
-        });
-    }
-    toChecksummedAddress(address) {
-        try {
-            return getAddress(address.toLowerCase());
-        }
-        catch {
-            return address;
-        }
-    }
-}
-//# sourceMappingURL=client.js.map