@web3auth/no-modal 8.12.4 → 9.0.0-alpha.0

package/LICENSE

@@ -1,6 +1,6 @@
-Copyright Web3Auth Inc. 2023. All rights reserved.
+Copyright Torus Labs Private Limited 2023. All rights reserved.
 
-You acknowledge and agree that Web3Auth Inc. (Web3Auth) (or Web3Auth's licensors) own all legal rights, titles and interests in and to the work, software, application, source code, documentation and any other documents in this repository (collectively, the “Program”), including any intellectual property rights which subsist in the Program (whether those rights happen to be registered or not, and wherever in the world those rights may exist), whether in source code or any other form.
+You acknowledge and agree that Torus Labs Private Limited (Web3Auth) (or Web3Auth's licensors) own all legal rights, titles and interests in and to the work, software, application, source code, documentation and any other documents in this repository (collectively, the “Program”), including any intellectual property rights which subsist in the Program (whether those rights happen to be registered or not, and wherever in the world those rights may exist), whether in source code or any other form.
 
 Subject to the limited license below, you may not (and you may not permit anyone else to) distribute, publish, copy, modify, merge, combine with another program, create derivative works of, reverse engineer, decompile or otherwise attempt to extract the source code of, the Program or any part thereof, except that you may contribute to this repository.
 

package/dist/lib.cjs/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var noModal = require('./noModal.js');
+
+
+
+exports.Web3AuthNoModal = noModal.Web3AuthNoModal;

package/dist/lib.cjs/noModal.js

@@ -0,0 +1,343 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var auth = require('@web3auth/auth');
+var base = require('@web3auth/base');
+var baseProvider = require('@web3auth/base-provider');
+var openloginAdapter = require('@web3auth/openlogin-adapter');
+var deepmerge = require('deepmerge');
+
+const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
+class Web3AuthNoModal extends auth.SafeEventEmitter {
+  constructor(options) {
+    var _options$chainConfig, _options$chainConfig2, _options$chainConfig3, _options$chainConfig4;
+    super();
+    _defineProperty(this, "coreOptions", void 0);
+    _defineProperty(this, "connectedAdapterName", null);
+    _defineProperty(this, "status", base.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "cachedAdapter", null);
+    _defineProperty(this, "walletAdapters", {});
+    _defineProperty(this, "commonJRPCProvider", null);
+    _defineProperty(this, "plugins", {});
+    _defineProperty(this, "storage", "localStorage");
+    if (!options.clientId) throw base.WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
+    if (options.enableLogging) base.log.enableAll();else base.log.setLevel("error");
+    if (!options.privateKeyProvider && !options.chainConfig) {
+      throw base.WalletInitializationError.invalidParams("Please provide chainConfig or privateKeyProvider");
+    }
+    options.chainConfig = options.chainConfig || options.privateKeyProvider.currentChainConfig;
+    if (!((_options$chainConfig = options.chainConfig) !== null && _options$chainConfig !== void 0 && _options$chainConfig.chainNamespace) || !Object.values(base.CHAIN_NAMESPACES).includes((_options$chainConfig2 = options.chainConfig) === null || _options$chainConfig2 === void 0 ? void 0 : _options$chainConfig2.chainNamespace)) throw base.WalletInitializationError.invalidParams("Please provide a valid chainNamespace in chainConfig");
+    if (options.storageKey === "session") this.storage = "sessionStorage";
+    this.cachedAdapter = base.storageAvailable(this.storage) ? window[this.storage].getItem(ADAPTER_CACHE_KEY) : null;
+    this.coreOptions = _objectSpread(_objectSpread({}, options), {}, {
+      chainConfig: _objectSpread(_objectSpread({}, base.getChainConfig((_options$chainConfig3 = options.chainConfig) === null || _options$chainConfig3 === void 0 ? void 0 : _options$chainConfig3.chainNamespace, (_options$chainConfig4 = options.chainConfig) === null || _options$chainConfig4 === void 0 ? void 0 : _options$chainConfig4.chainId) || {}), options.chainConfig)
+    });
+    this.subscribeToAdapterEvents = this.subscribeToAdapterEvents.bind(this);
+  }
+  get connected() {
+    return Boolean(this.connectedAdapterName);
+  }
+  get provider() {
+    if (this.status !== base.ADAPTER_STATUS.NOT_READY && this.commonJRPCProvider) {
+      return this.commonJRPCProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init() {
+    this.commonJRPCProvider = await baseProvider.CommonJRPCProvider.getProviderInstance({
+      chainConfig: this.coreOptions.chainConfig
+    });
+    let projectConfig;
+    try {
+      projectConfig = await base.fetchProjectConfig(this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
+    } catch (e) {
+      base.log.error("Failed to fetch project configurations", e);
+      throw base.WalletInitializationError.notReady("failed to fetch project configurations", e);
+    }
+    const initPromises = Object.keys(this.walletAdapters).map(async adapterName => {
+      this.subscribeToAdapterEvents(this.walletAdapters[adapterName]);
+      // if adapter doesn't have any chain config yet then set it based on provided namespace and chainId.
+      // if no chainNamespace or chainId is being provided, it will connect with mainnet.
+      if (!this.walletAdapters[adapterName].chainConfigProxy) {
+        const providedChainConfig = this.coreOptions.chainConfig;
+        if (!providedChainConfig.chainNamespace) throw base.WalletInitializationError.invalidParams("Please provide chainNamespace in chainConfig");
+        this.walletAdapters[adapterName].setAdapterSettings({
+          chainConfig: providedChainConfig,
+          sessionTime: this.coreOptions.sessionTime,
+          clientId: this.coreOptions.clientId,
+          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+          useCoreKitKey: this.coreOptions.useCoreKitKey
+        });
+      } else {
+        this.walletAdapters[adapterName].setAdapterSettings({
+          sessionTime: this.coreOptions.sessionTime,
+          clientId: this.coreOptions.clientId,
+          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+          useCoreKitKey: this.coreOptions.useCoreKitKey
+        });
+      }
+      if (adapterName === base.WALLET_ADAPTERS.OPENLOGIN) {
+        const openloginAdapter$1 = this.walletAdapters[adapterName];
+        const {
+          whitelabel
+        } = projectConfig;
+        this.coreOptions.uiConfig = deepmerge(base.cloneDeep(whitelabel), this.coreOptions.uiConfig);
+        if (!this.coreOptions.uiConfig.mode) this.coreOptions.uiConfig.mode = "light";
+        const {
+          sms_otp_enabled: smsOtpEnabled,
+          whitelist,
+          key_export_enabled: keyExportEnabled
+        } = projectConfig;
+        if (smsOtpEnabled !== undefined) {
+          openloginAdapter$1.setAdapterSettings({
+            loginConfig: {
+              [openloginAdapter.LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+                showOnModal: smsOtpEnabled,
+                showOnDesktop: smsOtpEnabled,
+                showOnMobile: smsOtpEnabled,
+                showOnSocialBackupFactor: smsOtpEnabled
+              }
+            }
+          });
+        }
+        if (whitelist) {
+          openloginAdapter$1.setAdapterSettings({
+            originData: whitelist.signed_urls
+          });
+        }
+        if (typeof keyExportEnabled === "boolean") {
+          this.coreOptions.privateKeyProvider.setKeyExportFlag(keyExportEnabled);
+          // dont know if this is required or not.
+          this.commonJRPCProvider.setKeyExportFlag(keyExportEnabled);
+        }
+        if (this.coreOptions.privateKeyProvider) {
+          if (openloginAdapter$1.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
+            throw base.WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for openlogin adapter");
+          }
+          openloginAdapter$1.setAdapterSettings({
+            privateKeyProvider: this.coreOptions.privateKeyProvider
+          });
+        }
+        openloginAdapter$1.setAdapterSettings({
+          whiteLabel: this.coreOptions.uiConfig
+        });
+        if (!openloginAdapter$1.privateKeyProvider) {
+          throw base.WalletInitializationError.invalidParams("privateKeyProvider is required for openlogin adapter");
+        }
+      } else if (adapterName === base.WALLET_ADAPTERS.WALLET_CONNECT_V2) {
+        const walletConnectAdapter = this.walletAdapters[adapterName];
+        const {
+          wallet_connect_enabled: walletConnectEnabled,
+          wallet_connect_project_id: walletConnectProjectId
+        } = projectConfig;
+        if (walletConnectEnabled === false) {
+          throw base.WalletInitializationError.invalidParams("Please enable wallet connect v2 addon on dashboard");
+        }
+        if (!walletConnectProjectId) throw base.WalletInitializationError.invalidParams("Invalid wallet connect project id. Please configure it on the dashboard");
+        walletConnectAdapter.setAdapterSettings({
+          adapterSettings: {
+            walletConnectInitOptions: {
+              projectId: walletConnectProjectId
+            }
+          }
+        });
+      }
+      return this.walletAdapters[adapterName].init({
+        autoConnect: this.cachedAdapter === adapterName
+      }).catch(e => base.log.error(e, adapterName));
+    });
+    await Promise.all(initPromises);
+    if (this.status === base.ADAPTER_STATUS.NOT_READY) {
+      this.status = base.ADAPTER_STATUS.READY;
+      this.emit(base.ADAPTER_EVENTS.READY);
+    }
+  }
+  getAdapter(adapterName) {
+    return this.walletAdapters[adapterName] || null;
+  }
+  configureAdapter(adapter) {
+    this.checkInitRequirements();
+    const providedChainConfig = this.coreOptions.chainConfig;
+    if (!providedChainConfig.chainNamespace) throw base.WalletInitializationError.invalidParams("Please provide chainNamespace in chainConfig");
+    const adapterAlreadyExists = this.walletAdapters[adapter.name];
+    if (adapterAlreadyExists) throw base.WalletInitializationError.duplicateAdapterError(`Wallet adapter for ${adapter.name} already exists`);
+    if (adapter.adapterNamespace !== base.ADAPTER_NAMESPACES.MULTICHAIN && adapter.adapterNamespace !== providedChainConfig.chainNamespace) throw base.WalletInitializationError.incompatibleChainNameSpace(`This wallet adapter belongs to ${adapter.adapterNamespace} which is incompatible with currently used namespace: ${providedChainConfig.chainNamespace}`);
+    if (adapter.adapterNamespace === base.ADAPTER_NAMESPACES.MULTICHAIN && adapter.currentChainNamespace && providedChainConfig.chainNamespace !== adapter.currentChainNamespace) {
+      // chainConfig checks are already validated in constructor so using typecast is safe here.
+      adapter.setAdapterSettings({
+        chainConfig: providedChainConfig
+      });
+    }
+    this.walletAdapters[adapter.name] = adapter;
+    return this;
+  }
+  clearCache() {
+    if (!base.storageAvailable(this.storage)) return;
+    window[this.storage].removeItem(ADAPTER_CACHE_KEY);
+    this.cachedAdapter = null;
+  }
+  async addChain(chainConfig) {
+    if (this.status === base.ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) return this.walletAdapters[this.connectedAdapterName].addChain(chainConfig);
+    if (this.commonJRPCProvider) {
+      return this.commonJRPCProvider.addChain(chainConfig);
+    }
+    throw base.WalletInitializationError.notReady(`No wallet is ready`);
+  }
+  async switchChain(params) {
+    if (this.status === base.ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) return this.walletAdapters[this.connectedAdapterName].switchChain(params);
+    if (this.commonJRPCProvider) {
+      return this.commonJRPCProvider.switchChain(params);
+    }
+    throw base.WalletInitializationError.notReady(`No wallet is ready`);
+  }
+
+  /**
+   * Connect to a specific wallet adapter
+   * @param walletName - Key of the walletAdapter to use.
+   */
+  async connectTo(walletName, loginParams) {
+    if (!this.walletAdapters[walletName] || !this.commonJRPCProvider) throw base.WalletInitializationError.notFound(`Please add wallet adapter for ${walletName} wallet, before connecting`);
+    const provider = await this.walletAdapters[walletName].connect(loginParams);
+    this.commonJRPCProvider.updateProviderEngineProxy(provider.provider || provider);
+    return this.provider;
+  }
+  async logout(options = {
+    cleanup: false
+  }) {
+    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
+    await this.walletAdapters[this.connectedAdapterName].disconnect(options);
+  }
+  async getUserInfo() {
+    base.log.debug("Getting user info", this.status, this.connectedAdapterName);
+    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
+    return this.walletAdapters[this.connectedAdapterName].getUserInfo();
+  }
+  async enableMFA(loginParams) {
+    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.connectedAdapterName !== base.WALLET_ADAPTERS.OPENLOGIN) throw base.WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
+    return this.walletAdapters[this.connectedAdapterName].enableMFA(loginParams);
+  }
+  async authenticateUser() {
+    if (this.status !== base.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base.WalletLoginError.notConnectedError(`No wallet is connected`);
+    return this.walletAdapters[this.connectedAdapterName].authenticateUser();
+  }
+  addPlugin(plugin) {
+    if (this.plugins[plugin.name]) throw base.WalletInitializationError.duplicateAdapterError(`Plugin ${plugin.name} already exist`);
+    if (plugin.pluginNamespace !== base.PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== this.coreOptions.chainConfig.chainNamespace) throw base.WalletInitializationError.incompatibleChainNameSpace(`This plugin belongs to ${plugin.pluginNamespace} namespace which is incompatible with currently used namespace: ${this.coreOptions.chainConfig.chainNamespace}`);
+    this.plugins[plugin.name] = plugin;
+    if (this.status === base.ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) {
+      // web3auth is already connected. can initialize plugins
+      this.connectToPlugins({
+        adapter: this.connectedAdapterName
+      });
+    }
+    return this;
+  }
+  getPlugin(name) {
+    return this.plugins[name] || null;
+  }
+  subscribeToAdapterEvents(walletAdapter) {
+    walletAdapter.on(base.ADAPTER_EVENTS.CONNECTED, async data => {
+      if (!this.commonJRPCProvider) throw base.WalletInitializationError.notFound(`CommonJrpcProvider not found`);
+      const {
+        provider
+      } = data;
+      this.commonJRPCProvider.updateProviderEngineProxy(provider.provider || provider);
+      this.status = base.ADAPTER_STATUS.CONNECTED;
+      this.connectedAdapterName = data.adapter;
+      this.cacheWallet(data.adapter);
+      base.log.debug("connected", this.status, this.connectedAdapterName);
+      this.connectToPlugins(data);
+      this.emit(base.ADAPTER_EVENTS.CONNECTED, _objectSpread({}, data));
+    });
+    walletAdapter.on(base.ADAPTER_EVENTS.DISCONNECTED, async () => {
+      // get back to ready state for rehydrating.
+      this.status = base.ADAPTER_STATUS.READY;
+      if (base.storageAvailable(this.storage)) {
+        const cachedAdapter = window[this.storage].getItem(ADAPTER_CACHE_KEY);
+        if (this.connectedAdapterName === cachedAdapter) {
+          this.clearCache();
+        }
+      }
+      base.log.debug("disconnected", this.status, this.connectedAdapterName);
+      await Promise.all(Object.values(this.plugins).map(plugin => {
+        return plugin.disconnect().catch(error => {
+          // swallow error if adapter doesn't supports this plugin.
+          if (error.code === 5211) {
+            return;
+          }
+          // throw error;
+          base.log.error(error);
+        });
+      }));
+      this.connectedAdapterName = null;
+      this.emit(base.ADAPTER_EVENTS.DISCONNECTED);
+    });
+    walletAdapter.on(base.ADAPTER_EVENTS.CONNECTING, data => {
+      this.status = base.ADAPTER_STATUS.CONNECTING;
+      this.emit(base.ADAPTER_EVENTS.CONNECTING, data);
+      base.log.debug("connecting", this.status, this.connectedAdapterName);
+    });
+    walletAdapter.on(base.ADAPTER_EVENTS.ERRORED, data => {
+      this.status = base.ADAPTER_STATUS.ERRORED;
+      this.clearCache();
+      this.emit(base.ADAPTER_EVENTS.ERRORED, data);
+      base.log.debug("errored", this.status, this.connectedAdapterName);
+    });
+    walletAdapter.on(base.ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, data => {
+      base.log.debug("adapter data updated", data);
+      this.emit(base.ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, data);
+    });
+    walletAdapter.on(base.ADAPTER_EVENTS.CACHE_CLEAR, data => {
+      base.log.debug("adapter cache clear", data);
+      if (base.storageAvailable(this.storage)) {
+        this.clearCache();
+      }
+    });
+  }
+  checkInitRequirements() {
+    if (this.status === base.ADAPTER_STATUS.CONNECTING) throw base.WalletInitializationError.notReady("Already pending connection");
+    if (this.status === base.ADAPTER_STATUS.CONNECTED) throw base.WalletInitializationError.notReady("Already connected");
+    if (this.status === base.ADAPTER_STATUS.READY) throw base.WalletInitializationError.notReady("Adapter is already initialized");
+  }
+  cacheWallet(walletName) {
+    if (!base.storageAvailable(this.storage)) return;
+    window[this.storage].setItem(ADAPTER_CACHE_KEY, walletName);
+    this.cachedAdapter = walletName;
+  }
+  connectToPlugins(data) {
+    Object.values(this.plugins).map(async plugin => {
+      try {
+        if (!plugin.SUPPORTED_ADAPTERS.includes(data.adapter)) {
+          return;
+        }
+        if (plugin.status === base.PLUGIN_STATUS.CONNECTED) return;
+        const {
+          openloginInstance
+        } = this.walletAdapters[this.connectedAdapterName];
+        const {
+          options,
+          sessionId,
+          sessionNamespace
+        } = openloginInstance || {};
+        await plugin.initWithWeb3Auth(this, options.whiteLabel);
+        await plugin.connect({
+          sessionId,
+          sessionNamespace
+        });
+      } catch (error) {
+        // swallow error if connector adapter doesn't supports this plugin.
+        if (error.code === 5211) {
+          return;
+        }
+        base.log.error(error);
+      }
+    });
+  }
+}
+
+exports.Web3AuthNoModal = Web3AuthNoModal;

package/dist/lib.esm/index.js

@@ -0,0 +1 @@
+export { Web3AuthNoModal } from './noModal.js';