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

package/dist/lib.cjs/adapters/wallet-connect-v2-adapter/walletConnectV2adapter.js

@@ -0,0 +1,376 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var Client = require('@walletconnect/sign-client');
+var utils$1 = require('@walletconnect/utils');
+var bs58 = require('bs58');
+var deepmerge = require('deepmerge');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index$1 = require('../../base/errors/index.js');
+var loglevel = require('../../base/loglevel.js');
+var index = require('../../base/wallet/index.js');
+var config = require('./config.js');
+var WalletConnectV2Provider = require('./WalletConnectV2Provider.js');
+var baseAdapter = require('../../base/adapter/baseAdapter.js');
+var constants = require('../../base/adapter/constants.js');
+var utils = require('../../base/adapter/utils.js');
+
+class WalletConnectV2Adapter extends baseAdapter.BaseAdapter {
+  constructor(options = {}) {
+    super(options);
+    _defineProperty(this, "name", index.WALLET_ADAPTERS.WALLET_CONNECT_V2);
+    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.MULTICHAIN);
+    _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.OTHER);
+    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "adapterOptions", {});
+    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "adapterData", {
+      uri: ""
+    });
+    _defineProperty(this, "connector", null);
+    _defineProperty(this, "activeSession", null);
+    _defineProperty(this, "wcProvider", null);
+    this.adapterOptions = _objectSpread({}, options);
+    this.setAdapterSettings(options);
+  }
+  get connected() {
+    return !!this.activeSession;
+  }
+  get provider() {
+    if (this.status !== constants.ADAPTER_STATUS.NOT_READY && this.wcProvider) {
+      return this.wcProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    var _this$adapterOptions$, _this$chainConfig, _this$chainConfig2;
+    super.checkInitializationRequirements();
+    const projectId = (_this$adapterOptions$ = this.adapterOptions.adapterSettings) === null || _this$adapterOptions$ === void 0 || (_this$adapterOptions$ = _this$adapterOptions$.walletConnectInitOptions) === null || _this$adapterOptions$ === void 0 ? void 0 : _this$adapterOptions$.projectId;
+    if (!projectId) {
+      throw index$1.WalletInitializationError.invalidParams("Wallet connect project id is required in wallet connect v2 adapter");
+    }
+    const wc2Settings = await config.getWalletConnectV2Settings((_this$chainConfig = this.chainConfig) === null || _this$chainConfig === void 0 ? void 0 : _this$chainConfig.chainNamespace, [(_this$chainConfig2 = this.chainConfig) === null || _this$chainConfig2 === void 0 ? void 0 : _this$chainConfig2.chainId], projectId);
+    if (!this.adapterOptions.loginSettings || Object.keys(this.adapterOptions.loginSettings).length === 0) {
+      this.adapterOptions.loginSettings = wc2Settings.loginSettings;
+    }
+    this.adapterOptions.adapterSettings = deepmerge(wc2Settings.adapterSettings || {}, this.adapterOptions.adapterSettings || {});
+    const {
+      adapterSettings
+    } = this.adapterOptions;
+    this.connector = await Client.init(adapterSettings === null || adapterSettings === void 0 ? void 0 : adapterSettings.walletConnectInitOptions);
+    this.wcProvider = new WalletConnectV2Provider.WalletConnectV2Provider({
+      config: {
+        chainConfig: this.chainConfig
+      },
+      connector: this.connector
+    });
+    this.emit(constants.ADAPTER_EVENTS.READY, index.WALLET_ADAPTERS.WALLET_CONNECT_V2);
+    this.status = constants.ADAPTER_STATUS.READY;
+    loglevel.log.debug("initializing wallet connect v2 adapter");
+    if (options.autoConnect) {
+      await this.checkForPersistedSession();
+      if (this.connected) {
+        this.rehydrated = true;
+        try {
+          await this.onConnectHandler();
+        } catch (error) {
+          loglevel.log.error("wallet auto connect", error);
+          this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+        }
+      } else {
+        this.status = constants.ADAPTER_STATUS.NOT_READY;
+        this.emit(constants.ADAPTER_EVENTS.CACHE_CLEAR);
+      }
+    }
+  }
+  async connect() {
+    super.checkConnectionRequirements();
+    if (!this.connector) throw index$1.WalletInitializationError.notReady("Wallet adapter is not ready yet");
+    try {
+      // if already connected
+      if (this.connected) {
+        await this.onConnectHandler();
+        return this.provider;
+      }
+      if (this.status !== constants.ADAPTER_STATUS.CONNECTING) {
+        await this.createNewSession();
+      }
+      return this.provider;
+    } catch (error) {
+      loglevel.log.error("Wallet connect v2 adapter error while connecting", error);
+      // ready again to be connected
+      this.status = constants.ADAPTER_STATUS.READY;
+      this.rehydrated = true;
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      const finalError = error instanceof index$1.Web3AuthError ? error : index$1.WalletLoginError.connectionError(`Failed to login with wallet connect: ${(error === null || error === void 0 ? void 0 : error.message) || ""}`, error);
+      throw finalError;
+    }
+  }
+
+  // should be called only before initialization.
+  setAdapterSettings(adapterSettings) {
+    var _this$adapterOptions$2, _this$adapterOptions, _this$adapterOptions$3, _this$adapterOptions2, _this$adapterOptions$4;
+    super.setAdapterSettings(adapterSettings);
+    const {
+      qrcodeModal,
+      walletConnectInitOptions
+    } = (adapterSettings === null || adapterSettings === void 0 ? void 0 : adapterSettings.adapterSettings) || {};
+    this.adapterOptions = _objectSpread(_objectSpread({}, this.adapterOptions), {}, {
+      adapterSettings: (_this$adapterOptions$2 = (_this$adapterOptions = this.adapterOptions) === null || _this$adapterOptions === void 0 ? void 0 : _this$adapterOptions.adapterSettings) !== null && _this$adapterOptions$2 !== void 0 ? _this$adapterOptions$2 : {},
+      loginSettings: (_this$adapterOptions$3 = (_this$adapterOptions2 = this.adapterOptions) === null || _this$adapterOptions2 === void 0 ? void 0 : _this$adapterOptions2.loginSettings) !== null && _this$adapterOptions$3 !== void 0 ? _this$adapterOptions$3 : {}
+    });
+    if (qrcodeModal) this.adapterOptions.adapterSettings.qrcodeModal = qrcodeModal;
+    if (walletConnectInitOptions) this.adapterOptions.adapterSettings.walletConnectInitOptions = _objectSpread(_objectSpread({}, (_this$adapterOptions$4 = this.adapterOptions.adapterSettings.walletConnectInitOptions) !== null && _this$adapterOptions$4 !== void 0 ? _this$adapterOptions$4 : {}), walletConnectInitOptions);
+    const {
+      loginSettings
+    } = adapterSettings;
+    if (loginSettings) this.adapterOptions.loginSettings = _objectSpread(_objectSpread({}, this.adapterOptions.loginSettings || {}), loginSettings);
+  }
+  async addChain(chainConfig, init = false) {
+    var _this$wcProvider;
+    super.checkAddChainRequirements(chainConfig, init);
+    await ((_this$wcProvider = this.wcProvider) === null || _this$wcProvider === void 0 ? void 0 : _this$wcProvider.addChain(chainConfig));
+    this.addChainConfig(chainConfig);
+  }
+  async switchChain(params, init = false) {
+    var _this$wcProvider2;
+    super.checkSwitchChainRequirements(params, init);
+    await ((_this$wcProvider2 = this.wcProvider) === null || _this$wcProvider2 === void 0 ? void 0 : _this$wcProvider2.switchChain({
+      chainId: params.chainId
+    }));
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  async getUserInfo() {
+    if (!this.connected) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async disconnect(options = {
+    cleanup: false,
+    sessionRemovedByWallet: false
+  }) {
+    var _this$activeSession, _this$activeSession2;
+    const {
+      cleanup
+    } = options;
+    if (!this.connector || !this.connected || !((_this$activeSession = this.activeSession) !== null && _this$activeSession !== void 0 && _this$activeSession.topic)) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!options.sessionRemovedByWallet) await this.connector.disconnect({
+      topic: (_this$activeSession2 = this.activeSession) === null || _this$activeSession2 === void 0 ? void 0 : _this$activeSession2.topic,
+      reason: utils$1.getSdkError("USER_DISCONNECTED")
+    });
+    this.rehydrated = false;
+    if (cleanup) {
+      this.connector = null;
+      this.status = constants.ADAPTER_STATUS.NOT_READY;
+      this.wcProvider = null;
+    } else {
+      // ready to connect again
+      this.status = constants.ADAPTER_STATUS.READY;
+    }
+    this.activeSession = null;
+    this.emit(constants.ADAPTER_EVENTS.DISCONNECTED);
+  }
+  async authenticateUser() {
+    if (!this.provider || this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError();
+    const {
+      chainNamespace,
+      chainId
+    } = this.chainConfig;
+    const accounts = await this.provider.request({
+      method: chainNamespace === IChainInterface.CHAIN_NAMESPACES.EIP155 ? "eth_accounts" : "getAccounts"
+    });
+    if (accounts && accounts.length > 0) {
+      const existingToken = utils.getSavedToken(accounts[0], this.name);
+      if (existingToken) {
+        const isExpired = utils.checkIfTokenIsExpired(existingToken);
+        if (!isExpired) {
+          return {
+            idToken: existingToken
+          };
+        }
+      }
+      const payload = {
+        domain: window.location.origin,
+        uri: window.location.href,
+        address: accounts[0],
+        chainId: parseInt(chainId, 16),
+        version: "1",
+        nonce: Math.random().toString(36).slice(2),
+        issuedAt: new Date().toISOString()
+      };
+      const challenge = await baseControllers.signChallenge(payload, chainNamespace);
+      const signedMessage = await this._getSignedMessage(challenge, accounts, chainNamespace);
+      const idToken = await baseControllers.verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.sessionTime, this.clientId, this.web3AuthNetwork);
+      utils.saveToken(accounts[0], this.name, idToken);
+      return {
+        idToken
+      };
+    }
+    throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+  cleanupPendingPairings() {
+    if (!this.connector) throw index$1.WalletInitializationError.notReady("Wallet adapter is not ready yet");
+    const inactivePairings = this.connector.pairing.getAll({
+      active: false
+    });
+    if (!utils$1.isValidArray(inactivePairings)) return;
+    inactivePairings.forEach(pairing => {
+      if (this.connector) {
+        this.connector.pairing.delete(pairing.topic, utils$1.getSdkError("USER_DISCONNECTED"));
+      }
+    });
+  }
+  async checkForPersistedSession() {
+    if (!this.connector) throw index$1.WalletInitializationError.notReady("Wallet adapter is not ready yet");
+    if (this.connector.session.length) {
+      const lastKeyIndex = this.connector.session.keys.length - 1;
+      this.activeSession = this.connector.session.get(this.connector.session.keys[lastKeyIndex]);
+    }
+    return this.activeSession;
+  }
+  async createNewSession(opts = {
+    forceNewSession: false
+  }) {
+    try {
+      var _this$activeSession3, _this$adapterOptions3;
+      if (!this.connector) throw index$1.WalletInitializationError.notReady("Wallet adapter is not ready yet");
+      if (!this.adapterOptions.loginSettings || Object.keys(this.adapterOptions.loginSettings).length === 0) throw index$1.WalletInitializationError.notReady("login settings are not set yet");
+      this.status = constants.ADAPTER_STATUS.CONNECTING;
+      this.emit(constants.ADAPTER_EVENTS.CONNECTING, {
+        adapter: index.WALLET_ADAPTERS.WALLET_CONNECT_V2
+      });
+      if (opts.forceNewSession && (_this$activeSession3 = this.activeSession) !== null && _this$activeSession3 !== void 0 && _this$activeSession3.topic) {
+        var _this$activeSession4;
+        await this.connector.disconnect({
+          topic: (_this$activeSession4 = this.activeSession) === null || _this$activeSession4 === void 0 ? void 0 : _this$activeSession4.topic,
+          reason: utils$1.getSdkError("USER_DISCONNECTED")
+        });
+      }
+      const {
+        uri,
+        approval
+      } = await this.connector.connect(this.adapterOptions.loginSettings);
+      const qrcodeModal = (_this$adapterOptions3 = this.adapterOptions) === null || _this$adapterOptions3 === void 0 || (_this$adapterOptions3 = _this$adapterOptions3.adapterSettings) === null || _this$adapterOptions3 === void 0 ? void 0 : _this$adapterOptions3.qrcodeModal;
+      // Open QRCode modal if a URI was returned (i.e. we're not connecting with an existing pairing).
+      if (uri) {
+        if (qrcodeModal) {
+          try {
+            await qrcodeModal.openModal({
+              uri
+            });
+            loglevel.log.debug("EVENT", "QR Code Modal closed");
+            this.status = constants.ADAPTER_STATUS.READY;
+            this.emit(constants.ADAPTER_EVENTS.READY, index.WALLET_ADAPTERS.WALLET_CONNECT_V2);
+          } catch (error) {
+            loglevel.log.error("unable to open qr code modal");
+          }
+        } else {
+          this.updateAdapterData({
+            uri
+          });
+        }
+      }
+      loglevel.log.info("awaiting session approval from wallet");
+
+      // Await session approval from the wallet.
+      const session = await approval();
+      this.activeSession = session;
+      // Handle the returned session (e.g. update UI to "connected" state).
+      await this.onConnectHandler();
+      if (qrcodeModal) {
+        qrcodeModal.closeModal();
+      }
+    } catch (error) {
+      var _message;
+      if ((_message = error.message) !== null && _message !== void 0 && _message.toLowerCase().includes("proposal expired")) {
+        // Retry if adapter status is still connecting
+        loglevel.log.info("current adapter status: ", this.status);
+        if (this.status === constants.ADAPTER_STATUS.CONNECTING) {
+          loglevel.log.info("retrying to create new wallet connect session since proposal expired");
+          return this.createNewSession({
+            forceNewSession: true
+          });
+        }
+        if (this.status === constants.ADAPTER_STATUS.READY) {
+          loglevel.log.info("ignoring proposal expired error since some other adapter is connected");
+          return;
+        }
+      }
+      loglevel.log.error("error while creating new wallet connect session", error);
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      throw error;
+    }
+  }
+  async onConnectHandler() {
+    var _this$adapterOptions$5;
+    if (!this.connector || !this.wcProvider) throw index$1.WalletInitializationError.notReady("Wallet adapter is not ready yet");
+    if (!this.chainConfig) throw index$1.WalletInitializationError.invalidParams("Chain config is not set");
+    this.subscribeEvents();
+    if ((_this$adapterOptions$5 = this.adapterOptions.adapterSettings) !== null && _this$adapterOptions$5 !== void 0 && _this$adapterOptions$5.qrcodeModal) {
+      this.wcProvider = new WalletConnectV2Provider.WalletConnectV2Provider({
+        config: {
+          chainConfig: this.chainConfig,
+          skipLookupNetwork: true
+        },
+        connector: this.connector
+      });
+    }
+    await this.wcProvider.setupProvider(this.connector);
+    this.cleanupPendingPairings();
+    this.status = constants.ADAPTER_STATUS.CONNECTED;
+    this.emit(constants.ADAPTER_EVENTS.CONNECTED, {
+      adapter: index.WALLET_ADAPTERS.WALLET_CONNECT_V2,
+      reconnected: this.rehydrated,
+      provider: this.provider
+    });
+  }
+  subscribeEvents() {
+    if (!this.connector) throw index$1.WalletInitializationError.notReady("Wallet adapter is not ready yet");
+    this.connector.events.on("session_update", ({
+      topic,
+      params
+    }) => {
+      if (!this.connector) return;
+      const {
+        namespaces
+      } = params;
+      const _session = this.connector.session.get(topic);
+      // Overwrite the `namespaces` of the existing session with the incoming one.
+      const updatedSession = _objectSpread(_objectSpread({}, _session), {}, {
+        namespaces
+      });
+      // Integrate the updated session state into your dapp state.
+      this.activeSession = updatedSession;
+    });
+    this.connector.events.on("session_delete", () => {
+      // Session was deleted -> reset the dapp state, clean up from user session, etc.
+      this.disconnect({
+        sessionRemovedByWallet: true
+      });
+    });
+  }
+  async _getSignedMessage(challenge, accounts, chainNamespace) {
+    const signedMessage = await this.provider.request({
+      method: chainNamespace === IChainInterface.CHAIN_NAMESPACES.EIP155 ? "personal_sign" : "signMessage",
+      params: chainNamespace === IChainInterface.CHAIN_NAMESPACES.EIP155 ? [challenge, accounts[0]] : {
+        message: Buffer.from(challenge)
+      }
+    });
+    if (chainNamespace === IChainInterface.CHAIN_NAMESPACES.SOLANA) return bs58.encode(signedMessage);
+    return signedMessage;
+  }
+}
+
+exports.WalletConnectV2Adapter = WalletConnectV2Adapter;

package/dist/lib.cjs/base/adapter/baseAdapter.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var auth = require('@web3auth/auth');
+var config = require('../chain/config.js');
+var IChainInterface = require('../chain/IChainInterface.js');
+var index = require('../errors/index.js');
+var index$1 = require('../wallet/index.js');
+var constants = require('./constants.js');
+
+class BaseAdapter extends auth.SafeEventEmitter {
+  constructor(options = {}) {
+    super();
+    _defineProperty(this, "adapterData", {});
+    _defineProperty(this, "sessionTime", 86400);
+    _defineProperty(this, "clientId", void 0);
+    _defineProperty(this, "web3AuthNetwork", auth.WEB3AUTH_NETWORK.MAINNET);
+    _defineProperty(this, "useCoreKitKey", undefined);
+    _defineProperty(this, "rehydrated", false);
+    // should be added in constructor or from setAdapterSettings function
+    // before calling init function.
+    _defineProperty(this, "chainConfig", null);
+    _defineProperty(this, "knownChainConfigs", {});
+    _defineProperty(this, "adapterNamespace", void 0);
+    _defineProperty(this, "currentChainNamespace", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "status", void 0);
+    this.setAdapterSettings(options);
+  }
+  get chainConfigProxy() {
+    return this.chainConfig ? _objectSpread({}, this.chainConfig) : null;
+  }
+  get connnected() {
+    return this.status === constants.ADAPTER_STATUS.CONNECTED;
+  }
+  setAdapterSettings(options) {
+    if (this.status === constants.ADAPTER_STATUS.READY) return;
+    if (options !== null && options !== void 0 && options.sessionTime) {
+      this.sessionTime = options.sessionTime;
+    }
+    if (options !== null && options !== void 0 && options.clientId) {
+      this.clientId = options.clientId;
+    }
+    if (options !== null && options !== void 0 && options.web3AuthNetwork) {
+      this.web3AuthNetwork = options.web3AuthNetwork;
+    }
+    if ((options === null || options === void 0 ? void 0 : options.useCoreKitKey) !== undefined) {
+      this.useCoreKitKey = options.useCoreKitKey;
+    }
+    const customChainConfig = options.chainConfig;
+    if (customChainConfig) {
+      if (!customChainConfig.chainNamespace) throw index.WalletInitializationError.notReady("ChainNamespace is required while setting chainConfig");
+      this.currentChainNamespace = customChainConfig.chainNamespace;
+      // chainId is optional in this function.
+      // we go with mainnet chainId by default.
+      const defaultChainConfig = config.getChainConfig(customChainConfig.chainNamespace, customChainConfig.chainId);
+      // NOTE: It is being forced casted to CustomChainConfig to handle OTHER Chainnamespace
+      // where chainConfig is not required.
+      const finalChainConfig = _objectSpread(_objectSpread({}, defaultChainConfig || {}), customChainConfig);
+      this.chainConfig = finalChainConfig;
+      this.addChainConfig(finalChainConfig);
+    }
+  }
+  checkConnectionRequirements() {
+    // we reconnect without killing existing wallet connect session on calling connect again.
+    if (this.name === index$1.WALLET_ADAPTERS.WALLET_CONNECT_V2 && this.status === constants.ADAPTER_STATUS.CONNECTING) return;
+    if (this.status === constants.ADAPTER_STATUS.CONNECTING) throw index.WalletInitializationError.notReady("Already connecting");
+    if (this.status === constants.ADAPTER_STATUS.CONNECTED) throw index.WalletLoginError.connectionError("Already connected");
+    if (this.status !== constants.ADAPTER_STATUS.READY) throw index.WalletLoginError.connectionError("Wallet adapter is not ready yet, Please wait for init function to resolve before calling connect/connectTo function");
+  }
+  checkInitializationRequirements() {
+    if (!this.clientId) throw index.WalletInitializationError.invalidParams("Please initialize Web3Auth with a valid clientId in constructor");
+    if (!this.chainConfig) throw index.WalletInitializationError.invalidParams("rpcTarget is required in chainConfig");
+    if (!this.chainConfig.rpcTarget && this.chainConfig.chainNamespace !== IChainInterface.CHAIN_NAMESPACES.OTHER) {
+      throw index.WalletInitializationError.invalidParams("rpcTarget is required in chainConfig");
+    }
+    if (!this.chainConfig.chainId && this.chainConfig.chainNamespace !== IChainInterface.CHAIN_NAMESPACES.OTHER) {
+      throw index.WalletInitializationError.invalidParams("chainID is required in chainConfig");
+    }
+    if (this.status === constants.ADAPTER_STATUS.NOT_READY) return;
+    if (this.status === constants.ADAPTER_STATUS.CONNECTED) throw index.WalletInitializationError.notReady("Already connected");
+    if (this.status === constants.ADAPTER_STATUS.READY) throw index.WalletInitializationError.notReady("Adapter is already initialized");
+  }
+  checkDisconnectionRequirements() {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index.WalletLoginError.disconnectionError("Not connected with wallet");
+  }
+  checkAddChainRequirements(chainConfig, init = false) {
+    if (!init && !this.provider) throw index.WalletLoginError.notConnectedError("Not connected with wallet.");
+    if (this.currentChainNamespace !== chainConfig.chainNamespace) {
+      throw index.WalletOperationsError.chainNamespaceNotAllowed("This adapter doesn't support this chainNamespace");
+    }
+  }
+  checkSwitchChainRequirements({
+    chainId
+  }, init = false) {
+    if (!init && !this.provider) throw index.WalletLoginError.notConnectedError("Not connected with wallet.");
+    if (!this.knownChainConfigs[chainId]) throw index.WalletLoginError.chainConfigNotAdded("Invalid chainId");
+  }
+  updateAdapterData(data) {
+    this.adapterData = data;
+    this.emit(constants.ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, {
+      adapterName: this.name,
+      data
+    });
+  }
+  addChainConfig(chainConfig) {
+    const currentConfig = this.knownChainConfigs[chainConfig.chainId];
+    this.knownChainConfigs[chainConfig.chainId] = _objectSpread(_objectSpread({}, currentConfig || {}), chainConfig);
+  }
+  getChainConfig(chainId) {
+    return this.knownChainConfigs[chainId] || null;
+  }
+}
+
+exports.BaseAdapter = BaseAdapter;

package/dist/lib.cjs/base/adapter/constants.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+
+const ADAPTER_STATUS = {
+  NOT_READY: "not_ready",
+  READY: "ready",
+  CONNECTING: "connecting",
+  CONNECTED: "connected",
+  DISCONNECTED: "disconnected",
+  ERRORED: "errored"
+};
+const ADAPTER_EVENTS = _objectSpread(_objectSpread({}, ADAPTER_STATUS), {}, {
+  ADAPTER_DATA_UPDATED: "adapter_data_updated",
+  CACHE_CLEAR: "cache_clear"
+});
+const ADAPTER_CATEGORY = {
+  EXTERNAL: "external",
+  IN_APP: "in_app"
+};
+
+exports.ADAPTER_CATEGORY = ADAPTER_CATEGORY;
+exports.ADAPTER_EVENTS = ADAPTER_EVENTS;
+exports.ADAPTER_STATUS = ADAPTER_STATUS;

package/dist/lib.cjs/base/adapter/utils.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var jwtDecode = require('jwt-decode');
+
+function storageAvailable(type) {
+  let storageExists = false;
+  let storageLength = 0;
+  let storage;
+  try {
+    storage = window[type];
+    storageExists = true;
+    storageLength = storage.length;
+    const x = "__storage_test__";
+    storage.setItem(x, x);
+    storage.removeItem(x);
+    return true;
+  } catch (err) {
+    const error = err;
+    return !!(error && (
+    // everything except Firefox
+    error.code === 22 ||
+    // Firefox
+    error.code === 1014 ||
+    // test name field too, because code might not be present
+    // everything except Firefox
+    error.name === "QuotaExceededError" ||
+    // Firefox
+    error.name === "NS_ERROR_DOM_QUOTA_REACHED") &&
+    // acknowledge QuotaExceededError only if there's something already stored
+    storageExists && storageLength !== 0);
+  }
+}
+const checkIfTokenIsExpired = token => {
+  const decoded = jwtDecode.jwtDecode(token);
+  if (!decoded.exp) {
+    return true;
+  }
+  if (decoded.exp < Math.floor(Date.now() / 1000)) {
+    return true;
+  }
+  return false;
+};
+const getSavedToken = (userAddress, issuer) => {
+  if (storageAvailable("localStorage")) {
+    return localStorage.getItem(`${userAddress.toLowerCase()}_${issuer}`);
+  }
+  return null;
+};
+const saveToken = (userAddress, issuer, token) => {
+  if (storageAvailable("localStorage")) {
+    return localStorage.setItem(`${userAddress.toLowerCase()}_${issuer}`, token);
+  }
+  return null;
+};
+const clearToken = (userAddress, issuer) => {
+  if (storageAvailable("localStorage")) {
+    return localStorage.removeItem(`${userAddress.toLowerCase()}_${issuer}`);
+  }
+  return null;
+};
+
+exports.checkIfTokenIsExpired = checkIfTokenIsExpired;
+exports.clearToken = clearToken;
+exports.getSavedToken = getSavedToken;
+exports.saveToken = saveToken;
+exports.storageAvailable = storageAvailable;

package/dist/lib.cjs/base/chain/IChainInterface.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CHAIN_NAMESPACES = {
+  EIP155: "eip155",
+  SOLANA: "solana",
+  CASPER: "casper",
+  XRPL: "xrpl",
+  OTHER: "other"
+};
+// eip155 for all evm chains
+
+const ADAPTER_NAMESPACES = {
+  EIP155: "eip155",
+  SOLANA: "solana",
+  CASPER: "casper",
+  XRPL: "xrpl",
+  MULTICHAIN: "multichain"
+};
+// eip155 for all evm chains
+
+exports.ADAPTER_NAMESPACES = ADAPTER_NAMESPACES;
+exports.CHAIN_NAMESPACES = CHAIN_NAMESPACES;