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

package/dist/757.noModal.cjs.js

@@ -0,0 +1,226 @@
+"use strict";
+(self["webpackChunk_web3auth_no_modal"] = self["webpackChunk_web3auth_no_modal"] || []).push([[757],{
+
+/***/ 1757:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  offchainLookup: () => (/* binding */ offchainLookup),
+  offchainLookupSignature: () => (/* binding */ offchainLookupSignature)
+});
+
+// UNUSED EXPORTS: ccipRequest, offchainLookupAbiItem
+
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/actions/public/call.js + 15 modules
+var call = __webpack_require__(1512);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/stringify.js
+var stringify = __webpack_require__(22);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/base.js + 1 modules
+var base = __webpack_require__(4323);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/utils.js
+var utils = __webpack_require__(476);
+;// ../../node_modules/viem/_esm/errors/ccip.js
+
+
+
+class OffchainLookupError extends base/* BaseError */.C {
+    constructor({ callbackSelector, cause, data, extraData, sender, urls, }) {
+        super(cause.shortMessage ||
+            'An error occurred while fetching for an offchain result.', {
+            cause,
+            metaMessages: [
+                ...(cause.metaMessages || []),
+                cause.metaMessages?.length ? '' : [],
+                'Offchain Gateway Call:',
+                urls && [
+                    '  Gateway URL(s):',
+                    ...urls.map((url) => `    ${(0,utils/* getUrl */.I)(url)}`),
+                ],
+                `  Sender: ${sender}`,
+                `  Data: ${data}`,
+                `  Callback selector: ${callbackSelector}`,
+                `  Extra data: ${extraData}`,
+            ].flat(),
+            name: 'OffchainLookupError',
+        });
+    }
+}
+class OffchainLookupResponseMalformedError extends base/* BaseError */.C {
+    constructor({ result, url }) {
+        super('Offchain gateway response is malformed. Response data must be a hex value.', {
+            metaMessages: [
+                `Gateway URL: ${(0,utils/* getUrl */.I)(url)}`,
+                `Response: ${(0,stringify/* stringify */.A)(result)}`,
+            ],
+            name: 'OffchainLookupResponseMalformedError',
+        });
+    }
+}
+class OffchainLookupSenderMismatchError extends base/* BaseError */.C {
+    constructor({ sender, to }) {
+        super('Reverted sender address does not match target contract address (`to`).', {
+            metaMessages: [
+                `Contract address: ${to}`,
+                `OffchainLookup sender address: ${sender}`,
+            ],
+            name: 'OffchainLookupSenderMismatchError',
+        });
+    }
+}
+//# sourceMappingURL=ccip.js.map
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/request.js
+var request = __webpack_require__(8820);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/abi/decodeErrorResult.js
+var decodeErrorResult = __webpack_require__(6395);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
+var encodeAbiParameters = __webpack_require__(8470);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/address.js
+var address = __webpack_require__(6077);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/address/isAddress.js
+var isAddress = __webpack_require__(5068);
+;// ../../node_modules/viem/_esm/utils/address/isAddressEqual.js
+
+
+function isAddressEqual(a, b) {
+    if (!(0,isAddress/* isAddress */.P)(a, { strict: false }))
+        throw new address/* InvalidAddressError */.M({ address: a });
+    if (!(0,isAddress/* isAddress */.P)(b, { strict: false }))
+        throw new address/* InvalidAddressError */.M({ address: b });
+    return a.toLowerCase() === b.toLowerCase();
+}
+//# sourceMappingURL=isAddressEqual.js.map
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/data/concat.js
+var concat = __webpack_require__(666);
+// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/data/isHex.js
+var isHex = __webpack_require__(3785);
+;// ../../node_modules/viem/_esm/utils/ccip.js
+
+
+
+
+
+
+
+
+
+const offchainLookupSignature = '0x556f1830';
+const offchainLookupAbiItem = {
+    name: 'OffchainLookup',
+    type: 'error',
+    inputs: [
+        {
+            name: 'sender',
+            type: 'address',
+        },
+        {
+            name: 'urls',
+            type: 'string[]',
+        },
+        {
+            name: 'callData',
+            type: 'bytes',
+        },
+        {
+            name: 'callbackFunction',
+            type: 'bytes4',
+        },
+        {
+            name: 'extraData',
+            type: 'bytes',
+        },
+    ],
+};
+async function offchainLookup(client, { blockNumber, blockTag, data, to, }) {
+    const { args } = (0,decodeErrorResult/* decodeErrorResult */.W)({
+        data,
+        abi: [offchainLookupAbiItem],
+    });
+    const [sender, urls, callData, callbackSelector, extraData] = args;
+    const { ccipRead } = client;
+    const ccipRequest_ = ccipRead && typeof ccipRead?.request === 'function'
+        ? ccipRead.request
+        : ccipRequest;
+    try {
+        if (!isAddressEqual(to, sender))
+            throw new OffchainLookupSenderMismatchError({ sender, to });
+        const result = await ccipRequest_({ data: callData, sender, urls });
+        const { data: data_ } = await (0,call/* call */.T)(client, {
+            blockNumber,
+            blockTag,
+            data: (0,concat/* concat */.xW)([
+                callbackSelector,
+                (0,encodeAbiParameters/* encodeAbiParameters */.h)([{ type: 'bytes' }, { type: 'bytes' }], [result, extraData]),
+            ]),
+            to,
+        });
+        return data_;
+    }
+    catch (err) {
+        throw new OffchainLookupError({
+            callbackSelector,
+            cause: err,
+            data,
+            extraData,
+            sender,
+            urls,
+        });
+    }
+}
+async function ccipRequest({ data, sender, urls, }) {
+    let error = new Error('An unknown error occurred.');
+    for (let i = 0; i < urls.length; i++) {
+        const url = urls[i];
+        const method = url.includes('{data}') ? 'GET' : 'POST';
+        const body = method === 'POST' ? { data, sender } : undefined;
+        const headers = method === 'POST' ? { 'Content-Type': 'application/json' } : {};
+        try {
+            const response = await fetch(url.replace('{sender}', sender).replace('{data}', data), {
+                body: JSON.stringify(body),
+                headers,
+                method,
+            });
+            let result;
+            if (response.headers.get('Content-Type')?.startsWith('application/json')) {
+                result = (await response.json()).data;
+            }
+            else {
+                result = (await response.text());
+            }
+            if (!response.ok) {
+                error = new request/* HttpRequestError */.Ci({
+                    body,
+                    details: result?.error
+                        ? (0,stringify/* stringify */.A)(result.error)
+                        : response.statusText,
+                    headers: response.headers,
+                    status: response.status,
+                    url,
+                });
+                continue;
+            }
+            if (!(0,isHex/* isHex */.q)(result)) {
+                error = new OffchainLookupResponseMalformedError({
+                    result,
+                    url,
+                });
+                continue;
+            }
+            return result;
+        }
+        catch (err) {
+            error = new request/* HttpRequestError */.Ci({
+                body,
+                details: err.message,
+                url,
+            });
+        }
+    }
+    throw error;
+}
+//# sourceMappingURL=ccip.js.map
+
+/***/ })
+
+}]);

package/dist/lib.cjs/adapters/auth-adapter/authAdapter.js

@@ -0,0 +1,262 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var auth = require('@web3auth/auth');
+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 baseAdapter = require('../../base/adapter/baseAdapter.js');
+var constants = require('../../base/adapter/constants.js');
+
+class AuthAdapter extends baseAdapter.BaseAdapter {
+  constructor(params = {}) {
+    super(params);
+    _defineProperty(this, "name", index.WALLET_ADAPTERS.AUTH);
+    _defineProperty(this, "adapterNamespace", IChainInterface.ADAPTER_NAMESPACES.MULTICHAIN);
+    _defineProperty(this, "type", constants.ADAPTER_CATEGORY.IN_APP);
+    _defineProperty(this, "authInstance", null);
+    _defineProperty(this, "status", constants.ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "currentChainNamespace", IChainInterface.CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "privateKeyProvider", null);
+    _defineProperty(this, "authOptions", void 0);
+    _defineProperty(this, "loginSettings", {
+      loginProvider: ""
+    });
+    this.setAdapterSettings(_objectSpread(_objectSpread({}, params.adapterSettings), {}, {
+      chainConfig: params.chainConfig,
+      clientId: params.clientId || "",
+      sessionTime: params.sessionTime,
+      web3AuthNetwork: params.web3AuthNetwork,
+      useCoreKitKey: params.useCoreKitKey,
+      privateKeyProvider: params.privateKeyProvider
+    }));
+    this.loginSettings = params.loginSettings || {
+      loginProvider: ""
+    };
+    this.privateKeyProvider = params.privateKeyProvider || null;
+  }
+  get chainConfigProxy() {
+    return this.chainConfig ? _objectSpread({}, this.chainConfig) : null;
+  }
+  get provider() {
+    if (this.status !== constants.ADAPTER_STATUS.NOT_READY && this.privateKeyProvider) {
+      return this.privateKeyProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    super.checkInitializationRequirements();
+    if (!this.clientId) throw index$1.WalletInitializationError.invalidParams("clientId is required before auth's initialization");
+    if (!this.authOptions) throw index$1.WalletInitializationError.invalidParams("authOptions is required before auth's initialization");
+    const isRedirectResult = this.authOptions.uxMode === auth.UX_MODE.REDIRECT;
+    this.authOptions = _objectSpread(_objectSpread({}, this.authOptions), {}, {
+      replaceUrlOnRedirect: isRedirectResult,
+      useCoreKitKey: this.useCoreKitKey
+    });
+    this.authInstance = new auth.Auth(_objectSpread(_objectSpread({}, this.authOptions), {}, {
+      clientId: this.clientId,
+      network: this.authOptions.network || this.web3AuthNetwork || auth.WEB3AUTH_NETWORK.SAPPHIRE_MAINNET
+    }));
+    loglevel.log.debug("initializing auth adapter init");
+    await this.authInstance.init();
+    if (!this.chainConfig) throw index$1.WalletInitializationError.invalidParams("chainConfig is required before initialization");
+    this.status = constants.ADAPTER_STATUS.READY;
+    this.emit(constants.ADAPTER_EVENTS.READY, index.WALLET_ADAPTERS.AUTH);
+    try {
+      loglevel.log.debug("initializing auth adapter");
+      const finalPrivKey = this._getFinalPrivKey();
+      // connect only if it is redirect result or if connect (adapter is cached/already connected in same session) is true
+      if (finalPrivKey && (options.autoConnect || isRedirectResult)) {
+        this.rehydrated = true;
+        await this.connect();
+      }
+    } catch (error) {
+      loglevel.log.error("Failed to connect with cached auth provider", error);
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+    }
+  }
+  async connect(params = {
+    loginProvider: ""
+  }) {
+    super.checkConnectionRequirements();
+    this.status = constants.ADAPTER_STATUS.CONNECTING;
+    this.emit(constants.ADAPTER_EVENTS.CONNECTING, _objectSpread(_objectSpread({}, params), {}, {
+      adapter: index.WALLET_ADAPTERS.AUTH
+    }));
+    try {
+      await this.connectWithProvider(params);
+      return this.provider;
+    } catch (error) {
+      loglevel.log.error("Failed to connect with auth provider", error);
+      // ready again to be connected
+      this.status = constants.ADAPTER_STATUS.READY;
+      this.emit(constants.ADAPTER_EVENTS.ERRORED, error);
+      if (error !== null && error !== void 0 && error.message.includes("user closed popup")) {
+        throw index$1.WalletLoginError.popupClosed();
+      } else if (error instanceof index$1.Web3AuthError) {
+        throw error;
+      }
+      throw index$1.WalletLoginError.connectionError("Failed to login with auth", error);
+    }
+  }
+  async enableMFA(params = {
+    loginProvider: ""
+  }) {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    try {
+      await this.authInstance.enableMFA(params);
+    } catch (error) {
+      loglevel.log.error("Failed to enable MFA with auth provider", error);
+      if (error instanceof index$1.Web3AuthError) {
+        throw error;
+      }
+      throw index$1.WalletLoginError.connectionError("Failed to enable MFA with auth", error);
+    }
+  }
+  async manageMFA(params = {
+    loginProvider: ""
+  }) {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    try {
+      await this.authInstance.manageMFA(params);
+    } catch (error) {
+      loglevel.log.error("Failed to manage MFA with auth provider", error);
+      if (error instanceof index$1.Web3AuthError) {
+        throw error;
+      }
+      throw index$1.WalletLoginError.connectionError("Failed to manage MFA with auth", error);
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    await this.authInstance.logout();
+    if (options.cleanup) {
+      this.status = constants.ADAPTER_STATUS.NOT_READY;
+      this.authInstance = null;
+      this.privateKeyProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = constants.ADAPTER_STATUS.READY;
+    }
+    this.rehydrated = false;
+    this.emit(constants.ADAPTER_EVENTS.DISCONNECTED);
+  }
+  async authenticateUser() {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    const userInfo = await this.getUserInfo();
+    return {
+      idToken: userInfo.idToken
+    };
+  }
+  async getUserInfo() {
+    if (this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    const userInfo = this.authInstance.getUserInfo();
+    return userInfo;
+  }
+
+  // should be called only before initialization.
+  setAdapterSettings(adapterSettings) {
+    super.setAdapterSettings(adapterSettings);
+    const defaultOptions = config.getAuthDefaultOptions();
+    loglevel.log.info("setting adapter settings", adapterSettings);
+    this.authOptions = deepmerge.all([defaultOptions.adapterSettings, this.authOptions || {}, adapterSettings || {}]);
+    if (adapterSettings.web3AuthNetwork) {
+      this.authOptions.network = adapterSettings.web3AuthNetwork;
+    }
+    if (adapterSettings.privateKeyProvider) {
+      this.privateKeyProvider = adapterSettings.privateKeyProvider;
+    }
+  }
+  async addChain(chainConfig, init = false) {
+    var _this$privateKeyProvi;
+    super.checkAddChainRequirements(chainConfig, init);
+    (_this$privateKeyProvi = this.privateKeyProvider) === null || _this$privateKeyProvi === void 0 || _this$privateKeyProvi.addChain(chainConfig);
+    this.addChainConfig(chainConfig);
+  }
+  async switchChain(params, init = false) {
+    var _this$privateKeyProvi2;
+    super.checkSwitchChainRequirements(params, init);
+    await ((_this$privateKeyProvi2 = this.privateKeyProvider) === null || _this$privateKeyProvi2 === void 0 ? void 0 : _this$privateKeyProvi2.switchChain(params));
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  _getFinalPrivKey() {
+    if (!this.authInstance) return "";
+    let finalPrivKey = this.authInstance.privKey;
+    // coreKitKey is available only for custom verifiers by default
+    if (this.useCoreKitKey) {
+      // this is to check if the user has already logged in but coreKitKey is not available.
+      // when useCoreKitKey is set to true.
+      // This is to ensure that when there is no user session active, we don't throw an exception.
+      if (this.authInstance.privKey && !this.authInstance.coreKitKey) {
+        throw index$1.WalletLoginError.coreKitKeyNotFound();
+      }
+      finalPrivKey = this.authInstance.coreKitKey;
+    }
+    return finalPrivKey;
+  }
+  _getFinalEd25519PrivKey() {
+    if (!this.authInstance) return "";
+    let finalPrivKey = this.authInstance.ed25519PrivKey;
+    // coreKitKey is available only for custom verifiers by default
+    if (this.useCoreKitKey) {
+      // this is to check if the user has already logged in but coreKitKey is not available.
+      // when useCoreKitKey is set to true.
+      // This is to ensure that when there is no user session active, we don't throw an exception.
+      if (this.authInstance.ed25519PrivKey && !this.authInstance.coreKitEd25519Key) {
+        throw index$1.WalletLoginError.coreKitKeyNotFound();
+      }
+      finalPrivKey = this.authInstance.coreKitEd25519Key;
+    }
+    return finalPrivKey;
+  }
+  async connectWithProvider(params = {
+    loginProvider: ""
+  }) {
+    var _params$extraLoginOpt;
+    if (!this.privateKeyProvider) throw index$1.WalletInitializationError.invalidParams("PrivateKey Provider is required before initialization");
+    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    const keyAvailable = this._getFinalPrivKey();
+    // if not logged in then login
+    if (!keyAvailable || (_params$extraLoginOpt = params.extraLoginOptions) !== null && _params$extraLoginOpt !== void 0 && _params$extraLoginOpt.id_token) {
+      var _params$extraLoginOpt2;
+      // always use "other" curve to return token with all keys encoded so wallet service can switch between evm and solana namespace
+      this.loginSettings.curve = auth.SUPPORTED_KEY_CURVES.OTHER;
+      if (!params.loginProvider && !this.loginSettings.loginProvider) throw index$1.WalletInitializationError.invalidParams("loginProvider is required for login");
+      await this.authInstance.login(deepmerge.all([this.loginSettings, params, {
+        extraLoginOptions: _objectSpread(_objectSpread({}, params.extraLoginOptions || {}), {}, {
+          login_hint: params.login_hint || ((_params$extraLoginOpt2 = params.extraLoginOptions) === null || _params$extraLoginOpt2 === void 0 ? void 0 : _params$extraLoginOpt2.login_hint)
+        })
+      }]));
+    }
+    let finalPrivKey = this._getFinalPrivKey();
+    if (finalPrivKey) {
+      if (this.currentChainNamespace === IChainInterface.CHAIN_NAMESPACES.SOLANA) {
+        finalPrivKey = this._getFinalEd25519PrivKey();
+      }
+      await this.privateKeyProvider.setupProvider(finalPrivKey);
+      this.status = constants.ADAPTER_STATUS.CONNECTED;
+      this.emit(constants.ADAPTER_EVENTS.CONNECTED, {
+        adapter: index.WALLET_ADAPTERS.AUTH,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+    }
+  }
+}
+
+exports.AuthAdapter = AuthAdapter;

package/dist/lib.cjs/adapters/auth-adapter/config.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var auth = require('@web3auth/auth');
+
+const getAuthDefaultOptions = () => {
+  return {
+    adapterSettings: {
+      network: auth.WEB3AUTH_NETWORK.SAPPHIRE_MAINNET,
+      clientId: "",
+      uxMode: auth.UX_MODE.POPUP
+    },
+    loginSettings: {},
+    privateKeyProvider: undefined
+  };
+};
+
+exports.getAuthDefaultOptions = getAuthDefaultOptions;

package/dist/lib.cjs/adapters/base-evm-adapter/baseEvmAdapter.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var config = require('../../base/chain/config.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var utils = require('../../base/adapter/utils.js');
+var baseAdapter = require('../../base/adapter/baseAdapter.js');
+var constants = require('../../base/adapter/constants.js');
+
+class BaseEvmAdapter extends baseAdapter.BaseAdapter {
+  async init(_) {
+    if (!this.chainConfig) this.chainConfig = config.getChainConfig(IChainInterface.CHAIN_NAMESPACES.EIP155, 1);
+  }
+  async authenticateUser() {
+    if (!this.provider || this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError();
+    const {
+      chainNamespace,
+      chainId
+    } = this.chainConfig;
+    const accounts = await this.provider.request({
+      method: "eth_accounts"
+    });
+    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 hexChallenge = `0x${Buffer.from(challenge, "utf8").toString("hex")}`;
+      const signedMessage = await this.provider.request({
+        method: "personal_sign",
+        params: [hexChallenge, accounts[0]]
+      });
+      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.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  }
+  async disconnectSession() {
+    super.checkDisconnectionRequirements();
+    const accounts = await this.provider.request({
+      method: "eth_accounts"
+    });
+    if (accounts && accounts.length > 0) {
+      utils.clearToken(accounts[0], this.name);
+    }
+  }
+  async disconnect() {
+    this.rehydrated = false;
+    this.emit(constants.ADAPTER_EVENTS.DISCONNECTED);
+  }
+}
+
+exports.BaseEvmAdapter = BaseEvmAdapter;

package/dist/lib.cjs/adapters/base-solana-adapter/baseSolanaAdapter.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var bs58 = require('bs58');
+var config = require('../../base/chain/config.js');
+var IChainInterface = require('../../base/chain/IChainInterface.js');
+var index = require('../../base/errors/index.js');
+var baseAdapter = require('../../base/adapter/baseAdapter.js');
+var constants = require('../../base/adapter/constants.js');
+var utils = require('../../base/adapter/utils.js');
+
+class BaseSolanaAdapter extends baseAdapter.BaseAdapter {
+  async init(_) {
+    if (!this.chainConfig) this.chainConfig = config.getChainConfig(IChainInterface.CHAIN_NAMESPACES.SOLANA, 1);
+  }
+  async authenticateUser() {
+    if (!this.provider || this.status !== constants.ADAPTER_STATUS.CONNECTED) throw index.WalletLoginError.notConnectedError();
+    const {
+      chainNamespace,
+      chainId
+    } = this.chainConfig;
+    const accounts = await this.provider.request({
+      method: "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 encodedMessage = new TextEncoder().encode(challenge);
+      const signedMessage = await this.provider.request({
+        method: "signMessage",
+        params: {
+          message: encodedMessage,
+          display: "utf8"
+        }
+      });
+      const idToken = await baseControllers.verifySignedChallenge(chainNamespace, bs58.encode(signedMessage), challenge, this.name, this.sessionTime, this.clientId, this.web3AuthNetwork);
+      utils.saveToken(accounts[0], this.name, idToken);
+      return {
+        idToken
+      };
+    }
+    throw index.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  }
+  async disconnectSession() {
+    super.checkDisconnectionRequirements();
+    const accounts = await this.provider.request({
+      method: "getAccounts"
+    });
+    if (accounts && accounts.length > 0) {
+      utils.clearToken(accounts[0], this.name);
+    }
+  }
+  async disconnect() {
+    this.rehydrated = false;
+    this.emit(constants.ADAPTER_EVENTS.DISCONNECTED);
+  }
+}
+
+exports.BaseSolanaAdapter = BaseSolanaAdapter;