@web3auth/no-modal 9.6.0 → 10.0.0-alpha.0

package/dist/lib.esm/adapters/default-solana-adapter/walletStandardAdapter.js

@@ -0,0 +1,136 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { StandardConnect, StandardDisconnect } from '@wallet-standard/features';
+import { ADAPTER_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { WalletLoginError } from '../../base/errors/index.js';
+import { log } from '../../base/loglevel.js';
+import { getSolanaChainByChainConfig } from './utils.js';
+import { WalletStandardProviderHandler } from './walletStandardHandler.js';
+import { BaseSolanaAdapter } from '../base-solana-adapter/baseSolanaAdapter.js';
+import { WalletStandardProvider } from '../../providers/solana-provider/providers/injectedProviders/walletStandardProvider.js';
+import { ADAPTER_CATEGORY, ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
+
+class WalletStandardAdapter extends BaseSolanaAdapter {
+  constructor(options) {
+    super(options);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "adapterNamespace", ADAPTER_NAMESPACES.SOLANA);
+    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.SOLANA);
+    _defineProperty(this, "type", ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "isInjected", true);
+    _defineProperty(this, "status", ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "wallet", null);
+    _defineProperty(this, "injectedProvider", null);
+    this.name = options.name;
+    // in VueJS, for some wallets e.g. Gate, Solflare, when connecting it throws error "attempted to get private field on non-instance"
+    // it seems that Vue create a Proxy object for the wallet object which causes the issue
+    // ref: https://stackoverflow.com/questions/64917686/vue-array-converted-to-proxy-object
+    this.wallet = ["gate", "solflare"].includes(this.name) ? Object.freeze(options.wallet) : options.wallet;
+  }
+  get provider() {
+    if (this.status !== ADAPTER_STATUS.NOT_READY && this.injectedProvider) {
+      return this.injectedProvider;
+    }
+    return null;
+  }
+  get isWalletConnected() {
+    return !!(this.status === ADAPTER_STATUS.CONNECTED && this.wallet.accounts.length > 0);
+  }
+  async init(options = {}) {
+    await super.init(options);
+    super.checkInitializationRequirements();
+    this.injectedProvider = new WalletStandardProvider({
+      config: {
+        chainConfig: this.chainConfig
+      }
+    });
+    const providerHandler = new WalletStandardProviderHandler({
+      wallet: this.wallet,
+      getCurrentChain: () => getSolanaChainByChainConfig(this.chainConfig)
+    });
+    this.injectedProvider.setupProvider(providerHandler);
+    this.status = ADAPTER_STATUS.READY;
+    this.emit(ADAPTER_EVENTS.READY, this.name);
+    try {
+      log.debug("initializing solana injected adapter");
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect();
+      }
+    } catch (error) {
+      log.error("Failed to connect with cached solana injected provider", error);
+      this.emit(ADAPTER_EVENTS.ERRORED, error);
+    }
+  }
+  async connect() {
+    try {
+      super.checkConnectionRequirements();
+      this.status = ADAPTER_STATUS.CONNECTING;
+      this.emit(ADAPTER_EVENTS.CONNECTING, {
+        adapter: this.name
+      });
+      const chainName = getSolanaChainByChainConfig(this.chainConfig);
+      if (!this.wallet.chains.find(chain => chain === chainName)) throw WalletLoginError.connectionError(`Chain ${chainName} not supported. Supported chains are ${this.wallet.chains.join(", ")}`);
+      if (!this.isWalletConnected) {
+        await this.wallet.features[StandardConnect].connect();
+      }
+      if (this.wallet.accounts.length === 0) throw WalletLoginError.connectionError();
+      this.status = ADAPTER_STATUS.CONNECTED;
+      this.emit(ADAPTER_EVENTS.CONNECTED, {
+        adapter: this.name,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+      return this.provider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = ADAPTER_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(ADAPTER_EVENTS.ERRORED, error);
+      throw error;
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    await super.disconnectSession();
+    try {
+      var _this$wallet$features;
+      await ((_this$wallet$features = this.wallet.features[StandardDisconnect]) === null || _this$wallet$features === void 0 ? void 0 : _this$wallet$features.disconnect());
+      if (options.cleanup) {
+        this.status = ADAPTER_STATUS.NOT_READY;
+        this.injectedProvider = null;
+      } else {
+        this.status = ADAPTER_STATUS.READY;
+      }
+      await super.disconnect();
+    } catch (error) {
+      this.emit(ADAPTER_EVENTS.ERRORED, WalletLoginError.disconnectionError(error === null || error === void 0 ? void 0 : error.message));
+    }
+  }
+  async getUserInfo() {
+    if (!this.isWalletConnected) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async addChain(chainConfig, init = false) {
+    var _this$injectedProvide;
+    super.checkAddChainRequirements(chainConfig, init);
+    (_this$injectedProvide = this.injectedProvider) === null || _this$injectedProvide === void 0 || _this$injectedProvide.addChain(chainConfig);
+    this.addChainConfig(chainConfig);
+  }
+  async switchChain(params, init = false) {
+    var _this$injectedProvide2;
+    super.checkSwitchChainRequirements(params, init);
+    await ((_this$injectedProvide2 = this.injectedProvider) === null || _this$injectedProvide2 === void 0 ? void 0 : _this$injectedProvide2.switchChain(params));
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  async enableMFA() {
+    throw new Error("Method not implemented.");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+
+export { WalletStandardAdapter };

package/dist/lib.esm/adapters/default-solana-adapter/walletStandardHandler.js

@@ -0,0 +1,75 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { SolanaSignMessage, SolanaSignTransaction, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
+import { PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js';
+import { SafeEventEmitter } from '@web3auth/auth';
+import BN from 'bn.js';
+import { WalletLoginError } from '../../base/errors/index.js';
+
+class WalletStandardProviderHandler extends SafeEventEmitter {
+  constructor({
+    wallet,
+    getCurrentChain
+  }) {
+    super();
+    _defineProperty(this, "wallet", null);
+    _defineProperty(this, "getCurrentChain", void 0);
+    this.wallet = wallet;
+    this.getCurrentChain = getCurrentChain;
+  }
+  get currentAccount() {
+    var _this$wallet;
+    const account = (_this$wallet = this.wallet) === null || _this$wallet === void 0 ? void 0 : _this$wallet.accounts[0];
+    if (!account) throw WalletLoginError.notConnectedError();
+    return account;
+  }
+  get publicKey() {
+    return new PublicKey(this.currentAccount.publicKey);
+  }
+  async signMessage(message) {
+    const account = this.currentAccount;
+    const signature = await this.wallet.features[SolanaSignMessage].signMessage({
+      account,
+      message
+    });
+    return {
+      signature: signature[0].signature,
+      publicKey: new BN(Buffer.from(account.publicKey))
+    };
+  }
+  async signTransaction(transaction) {
+    const account = this.currentAccount;
+    const output = await this.wallet.features[SolanaSignTransaction].signTransaction({
+      account,
+      transaction: transaction.serialize({
+        requireAllSignatures: false
+      }),
+      chain: this.getCurrentChain()
+    });
+    const isVersionedTransaction = transaction.version !== undefined || transaction instanceof VersionedTransaction;
+    if (isVersionedTransaction) {
+      return VersionedTransaction.deserialize(output[0].signedTransaction);
+    }
+    return Transaction.from(output[0].signedTransaction);
+  }
+  async signAllTransactions(transactions) {
+    return Promise.all(transactions.map(transaction => this.signTransaction(transaction)));
+  }
+  async signAndSendTransaction(transaction) {
+    const account = this.currentAccount;
+    const output = await this.wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
+      account,
+      transaction: transaction.serialize({
+        requireAllSignatures: false
+      }),
+      chain: this.getCurrentChain()
+    });
+    const [{
+      signature
+    }] = output;
+    return {
+      signature: new TextDecoder().decode(signature)
+    };
+  }
+}
+
+export { WalletStandardProviderHandler };

package/dist/lib.esm/adapters/wallet-connect-v2-adapter/WalletConnectV2Provider.js

@@ -0,0 +1,276 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getAccountsFromNamespaces, parseAccountId } from '@walletconnect/utils';
+import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { getChainConfig } from '../../base/chain/config.js';
+import { CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { WalletLoginError } from '../../base/errors/index.js';
+import { log } from '../../base/loglevel.js';
+import { switchChain, addChain, getAccounts, getEthProviderHandlers, getSolProviderHandlers } from './walletConnectV2Utils.js';
+import { createEthMiddleware, createEthChainSwitchMiddleware } from '../../providers/ethereum-provider/rpc/ethRpcMiddlewares.js';
+import { createEthJsonRpcClient } from '../../providers/ethereum-provider/rpc/jrpcClient.js';
+import { createSolanaMiddleware } from '../../providers/solana-provider/rpc/solanaRpcMiddlewares.js';
+import { createSolanaJsonRpcClient } from '../../providers/solana-provider/rpc/JrpcClient.js';
+import { BaseProvider } from '../../providers/base-provider/baseProvider.js';
+
+var _WalletConnectV2Provider;
+class WalletConnectV2Provider extends BaseProvider {
+  constructor({
+    config,
+    state,
+    connector
+  }) {
+    super({
+      config: {
+        chainConfig: config.chainConfig,
+        skipLookupNetwork: !!config.skipLookupNetwork
+      },
+      state: _objectSpread(_objectSpread({}, state || {}), {}, {
+        chainId: "loading",
+        accounts: []
+      })
+    });
+    _defineProperty(this, "connector", null);
+    this.connector = connector || null;
+  }
+  async enable() {
+    if (!this.connector) throw providerErrors.custom({
+      message: "Connector is not initialized, pass wallet connect connector in constructor",
+      code: 4902
+    });
+    await this.setupProvider(this.connector);
+    return this._providerEngineProxy.request({
+      method: "eth_accounts"
+    });
+  }
+  async setupProvider(connector) {
+    this.onConnectorStateUpdate(connector);
+    await this.setupEngine(connector);
+  }
+  async switchChain({
+    chainId
+  }) {
+    if (!this.connector) throw providerErrors.custom({
+      message: "Connector is not initialized, pass wallet connect connector in constructor",
+      code: 4902
+    });
+    const currentChainConfig = this.getChainConfig(chainId);
+    const {
+      chainId: currentChainId
+    } = this.config.chainConfig;
+    const currentNumChainId = parseInt(currentChainId, 16);
+    await switchChain({
+      connector: this.connector,
+      chainId: currentNumChainId,
+      newChainId: chainId
+    });
+    this.configure({
+      chainConfig: currentChainConfig
+    });
+    await this.setupEngine(this.connector);
+    this.lookupNetwork(this.connector);
+  }
+  async addChain(chainConfig) {
+    const {
+      chainId: currentChainId
+    } = this.config.chainConfig;
+    const numChainId = parseInt(currentChainId, 16);
+    await addChain({
+      connector: this.connector,
+      chainId: numChainId,
+      chainConfig: {
+        chainId: chainConfig.chainId,
+        chainName: chainConfig.displayName,
+        nativeCurrency: {
+          name: chainConfig.tickerName,
+          symbol: chainConfig.ticker.toLocaleUpperCase(),
+          decimals: chainConfig.decimals || 18
+        },
+        rpcUrls: [chainConfig.rpcTarget],
+        blockExplorerUrls: [chainConfig.blockExplorerUrl],
+        iconUrls: [chainConfig.logo]
+      }
+    });
+    super.addChain(chainConfig);
+  }
+
+  // no need to implement this method in wallet connect v2.
+  async lookupNetwork(_) {
+    const newChainId = this.config.chainConfig.chainId;
+    this.update({
+      chainId: newChainId
+    });
+    this.emit("chainChanged", newChainId);
+    this.emit("connect", {
+      chainId: newChainId
+    });
+    return this.config.chainConfig.chainId;
+  }
+  async setupEngine(connector) {
+    if (this.config.chainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      return this.setupEthEngine(connector);
+    } else if (this.config.chainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      return this.setupSolEngine(connector);
+    }
+    throw new Error(`Unsupported chainNamespace: ${this.config.chainConfig.chainNamespace}`);
+  }
+  async setupEthEngine(connector) {
+    const {
+      chainId
+    } = this.config.chainConfig;
+    const numChainId = parseInt(chainId, 16);
+    const providerHandlers = getEthProviderHandlers({
+      connector,
+      chainId: numChainId
+    });
+    const jrpcRes = await getAccounts(connector);
+    this.update({
+      accounts: jrpcRes || []
+    });
+    const ethMiddleware = createEthMiddleware(providerHandlers);
+    const chainSwitchMiddleware = this.getEthChainSwitchMiddleware();
+    const engine = new JRPCEngine();
+    const {
+      networkMiddleware
+    } = createEthJsonRpcClient(this.config.chainConfig);
+    engine.push(ethMiddleware);
+    engine.push(chainSwitchMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+  }
+  async setupSolEngine(connector) {
+    const {
+      chainId
+    } = this.config.chainConfig;
+    const providerHandlers = getSolProviderHandlers({
+      connector,
+      chainId
+    });
+    const jrpcRes = await getAccounts(connector);
+    this.update({
+      accounts: jrpcRes || []
+    });
+    const solMiddleware = createSolanaMiddleware(providerHandlers);
+    const engine = new JRPCEngine();
+    const {
+      networkMiddleware
+    } = createSolanaJsonRpcClient(this.config.chainConfig);
+    engine.push(solMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+  }
+  getEthChainSwitchMiddleware() {
+    const chainSwitchHandlers = {
+      addChain: async params => {
+        const {
+          chainId,
+          chainName,
+          rpcUrls,
+          blockExplorerUrls,
+          nativeCurrency,
+          iconUrls
+        } = params;
+        this.addChain({
+          chainNamespace: CHAIN_NAMESPACES.EIP155,
+          chainId,
+          ticker: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.symbol) || "ETH",
+          tickerName: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.name) || "Ether",
+          displayName: chainName,
+          rpcTarget: rpcUrls[0],
+          blockExplorerUrl: (blockExplorerUrls === null || blockExplorerUrls === void 0 ? void 0 : blockExplorerUrls[0]) || "",
+          decimals: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.decimals) || 18,
+          logo: (iconUrls === null || iconUrls === void 0 ? void 0 : iconUrls[0]) || "https://images.toruswallet.io/eth.svg"
+        });
+      },
+      switchChain: async params => {
+        const {
+          chainId
+        } = params;
+        await this.switchChain({
+          chainId
+        });
+      }
+    };
+    const chainSwitchMiddleware = createEthChainSwitchMiddleware(chainSwitchHandlers);
+    return chainSwitchMiddleware;
+  }
+  connectedTopic() {
+    var _this$connector;
+    if (!this.connector) throw WalletLoginError.notConnectedError("Wallet connect connector is not connected");
+    if ((_this$connector = this.connector) !== null && _this$connector !== void 0 && (_this$connector = _this$connector.session) !== null && _this$connector !== void 0 && _this$connector.length) {
+      var _this$connector$sessi;
+      // currently we are supporting only 1 active session
+      const lastKeyIndex = this.connector.session.keys.length - 1;
+      return (_this$connector$sessi = this.connector.session.get(this.connector.session.keys[lastKeyIndex])) === null || _this$connector$sessi === void 0 ? void 0 : _this$connector$sessi.topic;
+    }
+    return undefined;
+  }
+  checkIfAccountAllowed(address) {
+    if (!this.connector || !this.connectedTopic()) return false;
+    const sessionData = this.connector.session.get(this.connectedTopic());
+    const allAccounts = getAccountsFromNamespaces(sessionData.namespaces);
+    let accountAllowed = false;
+    for (const account of allAccounts) {
+      var _parsedAccount$addres;
+      const parsedAccount = parseAccountId(account);
+      if (((_parsedAccount$addres = parsedAccount.address) === null || _parsedAccount$addres === void 0 ? void 0 : _parsedAccount$addres.toLowerCase()) === (address === null || address === void 0 ? void 0 : address.toLowerCase())) {
+        accountAllowed = true;
+        break;
+      }
+    }
+    return accountAllowed;
+  }
+  async onConnectorStateUpdate(connector) {
+    connector.events.on("session_event", async payload => {
+      log.debug("session_event data", payload);
+      if (!this.provider) throw WalletLoginError.notConnectedError("Wallet connect connector is not connected");
+      const {
+        event
+      } = payload.params;
+      const {
+        name,
+        data
+      } = event || {};
+      // Check if accounts changed and trigger event
+      if (name === "accountsChanged" && data !== null && data !== void 0 && data.length && this.state.accounts[0] !== data[0] && this.checkIfAccountAllowed(data[0])) {
+        this.update({
+          accounts: data
+        });
+        this.emit("accountsChanged", data);
+      }
+      if (event.name === "chainChanged") {
+        if (!data) return;
+        const connectedChainId = data;
+        const connectedHexChainId = `0x${connectedChainId.toString(16)}`;
+
+        // Check if chainId changed and trigger event
+        if (connectedHexChainId && this.state.chainId !== connectedHexChainId) {
+          const maybeConfig = getChainConfig(CHAIN_NAMESPACES.EIP155, connectedHexChainId);
+          // Handle rpcUrl update
+          this.configure({
+            chainConfig: _objectSpread(_objectSpread({}, maybeConfig), {}, {
+              chainId: connectedHexChainId,
+              chainNamespace: CHAIN_NAMESPACES.EIP155
+            })
+          });
+          await this.setupEngine(connector);
+        }
+      }
+    });
+  }
+}
+_WalletConnectV2Provider = WalletConnectV2Provider;
+_defineProperty(WalletConnectV2Provider, "getProviderInstance", async params => {
+  const providerFactory = new _WalletConnectV2Provider({
+    config: {
+      chainConfig: params.chainConfig,
+      skipLookupNetwork: params.skipLookupNetwork
+    }
+  });
+  await providerFactory.setupProvider(params.connector);
+  return providerFactory;
+});
+
+export { WalletConnectV2Provider };

package/dist/lib.esm/adapters/wallet-connect-v2-adapter/config.js

@@ -0,0 +1,172 @@
+import { CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
+
+let DEFAULT_EIP155_METHODS = /*#__PURE__*/function (DEFAULT_EIP155_METHODS) {
+  DEFAULT_EIP155_METHODS["ETH_SEND_TRANSACTION"] = "eth_sendTransaction";
+  DEFAULT_EIP155_METHODS["ETH_SIGN_TRANSACTION"] = "eth_signTransaction";
+  DEFAULT_EIP155_METHODS["ETH_SIGN"] = "eth_sign";
+  DEFAULT_EIP155_METHODS["PERSONAL_SIGN"] = "personal_sign";
+  DEFAULT_EIP155_METHODS["ETH_SIGN_TYPED_DATA"] = "eth_signTypedData";
+  DEFAULT_EIP155_METHODS["ETH_SIGN_TYPED_DATA_V3"] = "eth_signTypedData_v3";
+  DEFAULT_EIP155_METHODS["ETH_SIGN_TYPED_DATA_V4"] = "eth_signTypedData_v4";
+  DEFAULT_EIP155_METHODS["ADD_ETHEREUM_CHAIN"] = "wallet_addEthereumChain";
+  DEFAULT_EIP155_METHODS["SWITCH_ETHEREUM_CHAIN"] = "wallet_switchEthereumChain";
+  return DEFAULT_EIP155_METHODS;
+}({});
+let DEFAULT_SOLANA_METHODS = /*#__PURE__*/function (DEFAULT_SOLANA_METHODS) {
+  DEFAULT_SOLANA_METHODS["SIGN_TRANSACTION"] = "solana_signTransaction";
+  DEFAULT_SOLANA_METHODS["SIGN_MESSAGE"] = "solana_signMessage";
+  return DEFAULT_SOLANA_METHODS;
+}({});
+let DEFAULT_EIP_155_EVENTS = /*#__PURE__*/function (DEFAULT_EIP_155_EVENTS) {
+  DEFAULT_EIP_155_EVENTS["ETH_CHAIN_CHANGED"] = "chainChanged";
+  DEFAULT_EIP_155_EVENTS["ETH_ACCOUNTS_CHANGED"] = "accountsChanged";
+  return DEFAULT_EIP_155_EVENTS;
+}({});
+let DEFAULT_SOLANA_EVENTS = /*#__PURE__*/function (DEFAULT_SOLANA_EVENTS) {
+  DEFAULT_SOLANA_EVENTS["SOL_CHAIN_CHANGED"] = "chainChanged";
+  DEFAULT_SOLANA_EVENTS["SOL_ACCOUNTS_CHANGED"] = "accountsChanged";
+  return DEFAULT_SOLANA_EVENTS;
+}({});
+const SOLANA_CAIP_CHAIN_MAP = {
+  "0x65": "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "0x66": "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z",
+  "0x67": "EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+};
+
+/**
+ * Extracts a name for the site from the DOM
+ */
+const getSiteName = window => {
+  const {
+    document
+  } = window;
+  const siteName = document.querySelector('head > meta[property="og:site_name"]');
+  if (siteName) {
+    return siteName.content;
+  }
+  const metaTitle = document.querySelector('head > meta[name="title"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+  if (document.title && document.title.length > 0) {
+    return document.title;
+  }
+  return window.location.hostname;
+};
+
+/**
+ * Returns whether the given image URL exists
+ * @param url - the url of the image
+ * @returns - whether the image exists
+ */
+function imgExists(url) {
+  return new Promise((resolve, reject) => {
+    try {
+      const img = document.createElement("img");
+      img.onload = () => resolve(true);
+      img.onerror = () => resolve(false);
+      img.src = url;
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+/**
+ * Extracts an icon for the site from the DOM
+ */
+async function getSiteIcon(window) {
+  const {
+    document
+  } = window;
+
+  // Use the site's favicon if it exists
+  let icon = document.querySelector('head > link[rel="shortcut icon"]');
+  if (icon && (await imgExists(icon.href))) {
+    return icon.href;
+  }
+
+  // Search through available icons in no particular order
+  icon = Array.from(document.querySelectorAll('head > link[rel="icon"]')).find(_icon => Boolean(_icon.href)) || null;
+  if (icon && (await imgExists(icon.href))) {
+    return icon.href;
+  }
+  return null;
+}
+
+/**
+ * Gets site metadata and returns it
+ *
+ */
+const getSiteMetadata = async () => ({
+  name: getSiteName(window),
+  icon: await getSiteIcon(window)
+});
+const getNamespacesFromChains = chains => {
+  const supportedNamespaces = [];
+  chains.forEach(chainId => {
+    const [namespace] = chainId.split(":");
+    if (!supportedNamespaces.includes(namespace)) {
+      supportedNamespaces.push(namespace);
+    }
+  });
+  return supportedNamespaces;
+};
+const getSupportedMethodsByNamespace = namespace => {
+  switch (namespace) {
+    case CHAIN_NAMESPACES.EIP155:
+      return Object.values(DEFAULT_EIP155_METHODS);
+    case CHAIN_NAMESPACES.SOLANA:
+      return Object.values(DEFAULT_SOLANA_METHODS);
+    default:
+      throw new Error(`No default methods for namespace: ${namespace}`);
+  }
+};
+const getSupportedEventsByNamespace = namespace => {
+  switch (namespace) {
+    case CHAIN_NAMESPACES.EIP155:
+      return Object.values(DEFAULT_EIP_155_EVENTS);
+    case CHAIN_NAMESPACES.SOLANA:
+      return Object.values(DEFAULT_SOLANA_EVENTS);
+    default:
+      throw new Error(`No default events for namespace: ${namespace}`);
+  }
+};
+const getRequiredNamespaces = chains => {
+  const selectedNamespaces = getNamespacesFromChains(chains);
+  return Object.fromEntries(selectedNamespaces.map(namespace => [namespace, {
+    methods: getSupportedMethodsByNamespace(namespace),
+    chains: chains.filter(chain => chain.startsWith(namespace)),
+    events: getSupportedEventsByNamespace(namespace)
+  }]));
+};
+const getWalletConnectV2Settings = async (namespace, chainIds, projectID) => {
+  if (namespace === CHAIN_NAMESPACES.EIP155 || namespace === CHAIN_NAMESPACES.SOLANA) {
+    const appMetadata = await getSiteMetadata();
+    const adapterSettings = {
+      walletConnectInitOptions: {
+        projectId: projectID,
+        relayUrl: "wss://relay.walletconnect.com",
+        metadata: {
+          name: appMetadata.name,
+          description: appMetadata.name,
+          url: window.location.origin,
+          icons: [appMetadata.icon || ""]
+        }
+      }
+    };
+    const chainNamespaces = chainIds.map(chainId => {
+      return `${namespace}:${namespace === CHAIN_NAMESPACES.SOLANA ? SOLANA_CAIP_CHAIN_MAP[chainId] : parseInt(chainId, 16)}`;
+    });
+    const loginSettings = {
+      optionalNamespaces: getRequiredNamespaces(chainNamespaces)
+    };
+    return {
+      adapterSettings,
+      loginSettings
+    };
+  }
+  throw new Error(`Unsupported chain namespace: ${namespace}`);
+};
+
+export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, SOLANA_CAIP_CHAIN_MAP, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings };