@dynamic-labs/starknet 4.0.0-alpha.4 → 4.0.0-alpha.41

package/src/wallets/injected/injected.cjs

@@ -0,0 +1,141 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var typesJs = require('@starknet-io/types-js');
+var utils = require('@dynamic-labs/utils');
+var StarknetWalletConnector = require('../../StarknetWalletConnector.cjs');
+
+class Injected extends StarknetWalletConnector.StarknetWalletConnector {
+    constructor(name, id, props) {
+        super(name, id, props);
+        this.overrideKey = props.overrideKey;
+    }
+    prompt(options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                throw new utils.DynamicError('No wallet available to send RPC requests to');
+            }
+            this.logger.debug('[prompt] Sending wallet_requestAccounts with silent_mode:', options.silently);
+            const accounts = yield wallet.request({
+                params: {
+                    silent_mode: options.silently,
+                },
+                type: 'wallet_requestAccounts',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestAccounts:', accounts);
+            if (accounts.length === 0) {
+                return {
+                    data: {
+                        account: undefined,
+                        chainId: undefined,
+                    },
+                    wallet,
+                };
+            }
+            const [account] = accounts;
+            this.logger.debug('[prompt] Sending wallet_requestChaindId');
+            const chainId = yield wallet.request({
+                type: 'wallet_requestChainId',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestChainId:', chainId);
+            return {
+                data: {
+                    account,
+                    chainId: BigInt(chainId),
+                },
+                wallet,
+            };
+        });
+    }
+    getAddress() {
+        const _super = Object.create(null, {
+            getAddress: { get: () => super.getAddress }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.isInstalledOnBrowser()) {
+                return _super.getAddress.call(this);
+            }
+            const inAppBrowserBase = (_a = this.walletBookWallet.mobile) === null || _a === void 0 ? void 0 : _a.inAppBrowser;
+            if (!inAppBrowserBase || !utils.isMobile()) {
+                return undefined;
+            }
+            const inAppBrowserTemplate = utils.template(inAppBrowserBase);
+            const deepLink = inAppBrowserTemplate({
+                encodedDappURI: window.location.toString().replace(/http(s)?:\/\//, ''),
+            });
+            window.location.href = deepLink;
+            return undefined;
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.walletData) === null || _a === void 0 ? void 0 : _a.account) {
+                this.logger.debug('[getConnectedAccounts] Found existing account:', this.walletData.account);
+                return [this.walletData.account];
+            }
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                return [];
+            }
+            const silently = yield this.shouldPromptSilently(wallet);
+            let data;
+            this.logger.debug('[getConnectedAccounts] No existing account, attempting to connect with silent mode:', silently);
+            try {
+                ({ data } = yield this.prompt({
+                    silently,
+                }));
+            }
+            catch (error) {
+                this.logger.debug(`[getConnectedAccounts] Silent connect errored out: ${error}`);
+                return [];
+            }
+            this.logger.debug(`[getConnectedAccounts] Connect returned account: ${data === null || data === void 0 ? void 0 : data.account}`);
+            if (!(data === null || data === void 0 ? void 0 : data.account)) {
+                return [];
+            }
+            this.walletData = data;
+            this.wallet = wallet;
+            this.setupEventListeners();
+            return [data.account];
+        });
+    }
+    shouldPromptSilently(wallet) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            /**
+             * In general, getConnectedAccounts should send a "silent" request to the wallet, meaning
+             * no popup will be displayed to the user. However, in the case that the user comes back
+             * to the dapp with a locked wallet, we do want to trigger a popup for the user to unlock
+             * their wallet, but only if their wallet has still granted permission to the dapp to access
+             * its data. That's what the following `wallet_getPermissions` RPC request does.
+             */
+            let silently = true;
+            try {
+                const permissions = yield wallet.request({
+                    type: 'wallet_getPermissions',
+                });
+                if (permissions.includes(typesJs.WALLET_API.Permission.ACCOUNTS)) {
+                    this.logger.debug('[getConnectedAccounts] Received `accounts` permission from wallet_getPermissions');
+                    silently = false;
+                }
+            }
+            catch (error) {
+                this.logger.debug('[getConnectedAccounts] `wallet_getPermissions` threw error:', error);
+            }
+            return silently;
+        });
+    }
+    getWindowWallet() {
+        this.logger.debug('[getWindowWallet] Looking for wallet from window:', this.id);
+        const wallet = window[`starknet_${this.id}`];
+        this.logger.debug('[getWindowWallet] Lookup result:', wallet);
+        return wallet;
+    }
+}
+
+exports.Injected = Injected;

package/src/wallets/injected/injected.d.ts

@@ -0,0 +1,10 @@
+import { StarknetWalletConnector } from '../../StarknetWalletConnector';
+import { PromptOptions, PromptResult } from '../../types';
+export declare class Injected extends StarknetWalletConnector {
+    constructor(name: string, id: string, props: any);
+    prompt(options: PromptOptions): Promise<PromptResult>;
+    getAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    private shouldPromptSilently;
+    private getWindowWallet;
+}

package/src/wallets/injected/injected.js

@@ -0,0 +1,137 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { WALLET_API } from '@starknet-io/types-js';
+import { DynamicError, isMobile, template } from '@dynamic-labs/utils';
+import { StarknetWalletConnector } from '../../StarknetWalletConnector.js';
+
+class Injected extends StarknetWalletConnector {
+    constructor(name, id, props) {
+        super(name, id, props);
+        this.overrideKey = props.overrideKey;
+    }
+    prompt(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                throw new DynamicError('No wallet available to send RPC requests to');
+            }
+            this.logger.debug('[prompt] Sending wallet_requestAccounts with silent_mode:', options.silently);
+            const accounts = yield wallet.request({
+                params: {
+                    silent_mode: options.silently,
+                },
+                type: 'wallet_requestAccounts',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestAccounts:', accounts);
+            if (accounts.length === 0) {
+                return {
+                    data: {
+                        account: undefined,
+                        chainId: undefined,
+                    },
+                    wallet,
+                };
+            }
+            const [account] = accounts;
+            this.logger.debug('[prompt] Sending wallet_requestChaindId');
+            const chainId = yield wallet.request({
+                type: 'wallet_requestChainId',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestChainId:', chainId);
+            return {
+                data: {
+                    account,
+                    chainId: BigInt(chainId),
+                },
+                wallet,
+            };
+        });
+    }
+    getAddress() {
+        const _super = Object.create(null, {
+            getAddress: { get: () => super.getAddress }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.isInstalledOnBrowser()) {
+                return _super.getAddress.call(this);
+            }
+            const inAppBrowserBase = (_a = this.walletBookWallet.mobile) === null || _a === void 0 ? void 0 : _a.inAppBrowser;
+            if (!inAppBrowserBase || !isMobile()) {
+                return undefined;
+            }
+            const inAppBrowserTemplate = template(inAppBrowserBase);
+            const deepLink = inAppBrowserTemplate({
+                encodedDappURI: window.location.toString().replace(/http(s)?:\/\//, ''),
+            });
+            window.location.href = deepLink;
+            return undefined;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.walletData) === null || _a === void 0 ? void 0 : _a.account) {
+                this.logger.debug('[getConnectedAccounts] Found existing account:', this.walletData.account);
+                return [this.walletData.account];
+            }
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                return [];
+            }
+            const silently = yield this.shouldPromptSilently(wallet);
+            let data;
+            this.logger.debug('[getConnectedAccounts] No existing account, attempting to connect with silent mode:', silently);
+            try {
+                ({ data } = yield this.prompt({
+                    silently,
+                }));
+            }
+            catch (error) {
+                this.logger.debug(`[getConnectedAccounts] Silent connect errored out: ${error}`);
+                return [];
+            }
+            this.logger.debug(`[getConnectedAccounts] Connect returned account: ${data === null || data === void 0 ? void 0 : data.account}`);
+            if (!(data === null || data === void 0 ? void 0 : data.account)) {
+                return [];
+            }
+            this.walletData = data;
+            this.wallet = wallet;
+            this.setupEventListeners();
+            return [data.account];
+        });
+    }
+    shouldPromptSilently(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /**
+             * In general, getConnectedAccounts should send a "silent" request to the wallet, meaning
+             * no popup will be displayed to the user. However, in the case that the user comes back
+             * to the dapp with a locked wallet, we do want to trigger a popup for the user to unlock
+             * their wallet, but only if their wallet has still granted permission to the dapp to access
+             * its data. That's what the following `wallet_getPermissions` RPC request does.
+             */
+            let silently = true;
+            try {
+                const permissions = yield wallet.request({
+                    type: 'wallet_getPermissions',
+                });
+                if (permissions.includes(WALLET_API.Permission.ACCOUNTS)) {
+                    this.logger.debug('[getConnectedAccounts] Received `accounts` permission from wallet_getPermissions');
+                    silently = false;
+                }
+            }
+            catch (error) {
+                this.logger.debug('[getConnectedAccounts] `wallet_getPermissions` threw error:', error);
+            }
+            return silently;
+        });
+    }
+    getWindowWallet() {
+        this.logger.debug('[getWindowWallet] Looking for wallet from window:', this.id);
+        const wallet = window[`starknet_${this.id}`];
+        this.logger.debug('[getWindowWallet] Lookup result:', wallet);
+        return wallet;
+    }
+}
+
+export { Injected };

package/src/wallets/{metamask.d.ts → injected/metamask.d.ts}

@@ -1,6 +1,5 @@
-import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
-import StarknetProvider from '../starknetWalletConnector';
-export declare class MetaMask extends StarknetProvider implements WalletConnectorBase {
+import { Injected } from './injected';
+export declare class MetaMask extends Injected {
     overrideKey: string;
     private currentChainId;
     private intervalId;
@@ -10,5 +9,4 @@ export declare class MetaMask extends StarknetProvider implements WalletConnecto
     setupEventListeners(): void;
     teardownEventListeners(): Promise<void>;
     endSession(): Promise<void>;
-    getConnectedAccounts(): Promise<string[]>;
 }

package/src/starknetWalletConnector.cjs

@@ -1,320 +0,0 @@
-'use client'
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _tslib = require('../_virtual/_tslib.cjs');
-var getStarknetCore = require('get-starknet-core');
-var starknet = require('starknet');
-var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
-var utils = require('@dynamic-labs/utils');
-var constants = require('./constants.cjs');
-var ethereumContractAbi = require('./ethereumContractAbi.cjs');
-var convertors = require('./utils/convertors.cjs');
-var StarknetWallet = require('./wallet/StarknetWallet.cjs');
-
-const ACCOUNT_CHANGED_EVENT_LISTENER = 'accountsChanged';
-const NETWORK_CHANGED_EVENT_LISTENER = 'networkChanged';
-class StarknetWalletConnector extends walletConnectorCore.WalletConnectorBase {
-    constructor(name, windowKey, opts) {
-        var _a;
-        super(opts);
-        this.STARKNET_VERSION = 'v5';
-        this.ChainWallet = StarknetWallet.StarknetWallet;
-        this.connectedChain = 'STARK';
-        this.supportedChains = ['STARK'];
-        this.switchNetworkOnlyFromWallet = true;
-        // required for metamask snap integration as MM snaps don't have event listeners
-        this.canSetEventListeners = true;
-        this.name = name;
-        this.windowKey = windowKey;
-        this.starknetNetworks = opts.starknetNetworks;
-        this.chainRpcProviders = opts.chainRpcProviders;
-        (_a = this.chainRpcProviders) === null || _a === void 0 ? void 0 : _a.registerStarknetProviders();
-    }
-    get walletBookWallet() {
-        return this.walletBook.wallets[this.key];
-    }
-    // abstracting this method to a function due to some wallets (bitget)
-    // having non-standard use of the isConnected flag. This allows for us to use other flags to determine connectivity
-    isProviderConnected() {
-        var _a;
-        const wallet = this.getWallet();
-        return (_a = wallet === null || wallet === void 0 ? void 0 : wallet.isConnected) !== null && _a !== void 0 ? _a : false;
-    }
-    getPublicClient() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.starknetNetworks === undefined ||
-                this.starknetNetworks.length === 0)
-                return;
-            const configurations = {
-                cosmos: [],
-                evm: undefined,
-                solana: undefined,
-                starknet: this.starknetNetworks,
-            };
-            const chainId = yield this.getNetwork();
-            const starknetRpcProvider = (_a = this.chainRpcProviders) === null || _a === void 0 ? void 0 : _a.getStarknetRpcProviderByChainId(configurations, chainId);
-            return starknetRpcProvider === null || starknetRpcProvider === void 0 ? void 0 : starknetRpcProvider.provider;
-        });
-    }
-    /**
-     * returns starknet wallet network id
-     */
-    getNetwork() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const wallet = this.getWallet();
-            if (!wallet) {
-                return Promise.resolve(undefined);
-            }
-            if (!this.isProviderConnected()) {
-                yield wallet.enable({ starknetVersion: this.STARKNET_VERSION });
-            }
-            return Promise.resolve((_a = wallet.provider) === null || _a === void 0 ? void 0 : _a.getChainId());
-        });
-    }
-    connect() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const wallet = this.getWallet();
-            try {
-                if (wallet && !this.isProviderConnected()) {
-                    yield wallet.enable({ starknetVersion: this.STARKNET_VERSION });
-                    localStorage.setItem('dynamic_should_have_wallet', 'true');
-                }
-            }
-            catch (err) {
-                walletConnectorCore.logger.error(err);
-            }
-        });
-    }
-    getAddress() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const wallet = this.getWallet();
-            if (!this.isInstalledOnBrowser() &&
-                utils.isMobile() &&
-                this.walletBookWallet.mobile &&
-                this.walletBookWallet.mobile.inAppBrowser &&
-                this.mobileExperience === 'in-app-browser') {
-                const inAppBrowserCompiledTemplate = utils.template(this.walletBookWallet.mobile.inAppBrowser);
-                const deepLink = inAppBrowserCompiledTemplate({
-                    encodedDappURI: encodeURIComponent(window.location.toString()),
-                });
-                window.location.assign(deepLink);
-            }
-            if (wallet && !this.isProviderConnected()) {
-                yield (wallet === null || wallet === void 0 ? void 0 : wallet.isPreauthorized());
-                yield this.connect();
-            }
-            return Promise.resolve(wallet === null || wallet === void 0 ? void 0 : wallet.selectedAddress);
-        });
-    }
-    getWalletAccount() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const wallet = this.getWallet();
-            return wallet === null || wallet === void 0 ? void 0 : wallet.account;
-        });
-    }
-    getProvider() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const wallet = yield this.getWallet();
-            return wallet === null || wallet === void 0 ? void 0 : wallet.provider;
-        });
-    }
-    signMessage(messageToSign) {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            // FetchPublicAddress also handles the connection to the wallet this is why we call it before getWallet.
-            const walletAddress = yield this.getAddress();
-            const wallet = this.getWallet();
-            if (!walletAddress || !wallet) {
-                walletConnectorCore.logger.error('Could not fetch wallet address for signing message');
-                return undefined;
-            }
-            const encodedMessage = convertors.formatTypedDataMessage(messageToSign, (yield wallet.provider.getChainId()));
-            const signature = yield wallet.account.signMessage(encodedMessage);
-            return signature === null || signature === void 0 ? void 0 : signature.join(',');
-        });
-    }
-    getBalance(address) {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const provider = yield this.getProvider();
-            if (!provider) {
-                walletConnectorCore.logger.error('Could not find provider for getting balance');
-                return undefined;
-            }
-            const contract = new starknet.Contract(ethereumContractAbi, constants.ETH_STARKNET_ADDRESS, provider);
-            try {
-                const { balance } = yield contract.balanceOf(address);
-                /**
-                 * Dividing by 1e18 as the returned balance is a Gwei number.
-                 * Read more here: https://www.investopedia.com/terms/g/gwei-ethereum.asp#toc-what-is-gwei
-                 */
-                return (Number(starknet.cairo.uint256(balance.low).low) / 1e18).toFixed(6);
-            }
-            catch (error) {
-                walletConnectorCore.logger.error(error);
-                throw new utils.DynamicError('Something went wrong');
-            }
-        });
-    }
-    endSession() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            localStorage.removeItem('dynamic_should_have_wallet');
-            getStarknetCore.getStarknet().disconnect({ clearLastWallet: true });
-        });
-    }
-    getWallet() {
-        let starknetWindowInstance = window[`starknet_${this.windowKey}`];
-        if (starknetWindowInstance !== undefined) {
-            return starknetWindowInstance;
-        }
-        else {
-            starknetWindowInstance = window['starknet'];
-            if ((starknetWindowInstance === null || starknetWindowInstance === void 0 ? void 0 : starknetWindowInstance.name) === this.name) {
-                return starknetWindowInstance;
-            }
-        }
-        return undefined;
-    }
-    isInstalledOnBrowser() {
-        return this.getWallet() !== undefined;
-    }
-    getConnectedAccounts() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const wallet = this.getWallet();
-            if (!wallet) {
-                return [];
-            }
-            try {
-                yield this.reconnectIfNeeded(wallet);
-            }
-            catch (e) {
-                return [];
-            }
-            const getSelectedAddress = () => wallet.selectedAddress
-                ? Promise.resolve([wallet.selectedAddress])
-                : Promise.reject();
-            return utils.retryableFn(getSelectedAddress, {
-                fallbackValue: [],
-                retryIntervalMs: 100,
-                retryStrategy: 'timeout-and-rejection',
-            });
-        });
-    }
-    reconnectIfNeeded(wallet) {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const needsReconnection = !this.isProviderConnected() && (yield wallet.isPreauthorized());
-            if (needsReconnection) {
-                /**
-                 * this is a hack for braavos
-                 * it is needed because the wallet doesn't return any addresses or connected state
-                 * without a reconnection, and when the wallet is locked, the connect call never resolves
-                 */
-                if (localStorage.getItem('dynamic_should_have_wallet') === 'true') {
-                    try {
-                        yield utils.retryableFn(this.connect.bind(this), {
-                            maxRetries: 0,
-                            retryStrategy: 'timeout-only',
-                            timeoutMs: 1000,
-                        });
-                    }
-                    catch (_a) {
-                        localStorage.removeItem('dynamic_should_have_wallet');
-                        throw new Error('Could not reconnect');
-                    }
-                }
-                else {
-                    yield this.connect();
-                }
-            }
-        });
-    }
-    setupEventListeners() {
-        if (!this.canSetEventListeners)
-            return;
-        const wallet = this.getWallet();
-        if (!wallet) {
-            return walletConnectorCore.logger.error('Wallet has not been found');
-        }
-        this.handleAccountChange = (address) => _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (!address) {
-                this.emit('disconnect');
-                return;
-            }
-            if (address.toString()) {
-                this.emit('accountChange', { accounts: [address.toString()] });
-            }
-        });
-        this.handleNetworkChange = (network) => _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (!network) {
-                this.emit('disconnect');
-                return;
-            }
-            const chain = this.mapNetworkNameToChainId(network.toString());
-            if (chain) {
-                this.emit('chainChange', { chain });
-            }
-        });
-        wallet === null || wallet === void 0 ? void 0 : wallet.on(ACCOUNT_CHANGED_EVENT_LISTENER, this.handleAccountChange);
-        wallet === null || wallet === void 0 ? void 0 : wallet.on(NETWORK_CHANGED_EVENT_LISTENER, this.handleNetworkChange);
-    }
-    teardownEventListeners() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (!this.canSetEventListeners)
-                return;
-            const wallet = this.getWallet();
-            if (this.handleAccountChange) {
-                wallet === null || wallet === void 0 ? void 0 : wallet.off(ACCOUNT_CHANGED_EVENT_LISTENER, this.handleAccountChange);
-                this.handleAccountChange = undefined;
-            }
-            if (this.handleNetworkChange) {
-                wallet === null || wallet === void 0 ? void 0 : wallet.off(NETWORK_CHANGED_EVENT_LISTENER, this.handleNetworkChange);
-                this.handleNetworkChange = undefined;
-            }
-        });
-    }
-    mapNetworkNameToChainId(networkNameOrChainId) {
-        if (networkNameOrChainId === starknet.constants.NetworkName.SN_MAIN ||
-            networkNameOrChainId.includes('mainnet') ||
-            networkNameOrChainId === starknet.constants.StarknetChainId.SN_MAIN) {
-            return starknet.constants.StarknetChainId.SN_MAIN;
-        }
-        else if (networkNameOrChainId === starknet.constants.NetworkName.SN_GOERLI ||
-            networkNameOrChainId.includes('goerli') ||
-            networkNameOrChainId === starknet.constants.StarknetChainId.SN_GOERLI) {
-            return starknet.constants.StarknetChainId.SN_GOERLI;
-        }
-        else if (networkNameOrChainId === starknet.constants.NetworkName.SN_SEPOLIA ||
-            networkNameOrChainId.includes('sepolia') ||
-            networkNameOrChainId === starknet.constants.StarknetChainId.SN_SEPOLIA) {
-            return starknet.constants.StarknetChainId.SN_SEPOLIA;
-        }
-        else {
-            walletConnectorCore.logger.error('Unknown networkName', networkNameOrChainId);
-            return undefined;
-        }
-    }
-    mapChainIdToNetworkName(chainIdOrNetworkName) {
-        if (chainIdOrNetworkName === starknet.constants.StarknetChainId.SN_MAIN ||
-            chainIdOrNetworkName === starknet.constants.NetworkName.SN_MAIN) {
-            return starknet.constants.NetworkName.SN_MAIN;
-        }
-        else if (chainIdOrNetworkName === starknet.constants.StarknetChainId.SN_GOERLI ||
-            chainIdOrNetworkName === starknet.constants.NetworkName.SN_GOERLI) {
-            return starknet.constants.NetworkName.SN_GOERLI;
-        }
-        else if (chainIdOrNetworkName === starknet.constants.StarknetChainId.SN_SEPOLIA ||
-            chainIdOrNetworkName === starknet.constants.NetworkName.SN_SEPOLIA) {
-            return starknet.constants.NetworkName.SN_SEPOLIA;
-        }
-        else {
-            walletConnectorCore.logger.error('Unknown chainId', chainIdOrNetworkName);
-            return undefined;
-        }
-    }
-}
-
-exports.ACCOUNT_CHANGED_EVENT_LISTENER = ACCOUNT_CHANGED_EVENT_LISTENER;
-exports.NETWORK_CHANGED_EVENT_LISTENER = NETWORK_CHANGED_EVENT_LISTENER;
-exports["default"] = StarknetWalletConnector;