@web3auth/no-modal 10.16.0 → 11.0.0-beta.1

package/dist/lib.cjs/account-linking/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var rest = require('./rest.js');
+
+
+
+exports.makeAccountLinkingRequest = rest.makeAccountLinkingRequest;
+exports.makeAccountUnlinkingRequest = rest.makeAccountUnlinkingRequest;

package/dist/lib.cjs/account-linking/react.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var react = require('react');
+require('@babel/runtime/helpers/objectSpread2');
+require('@babel/runtime/helpers/defineProperty');
+require('@segment/analytics-next');
+require('../base/loglevel.js');
+require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
+require('@web3auth/auth');
+var index = require('../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../base/constants.js');
+require('../base/wallet/index.js');
+require('../base/connector/connectorStatus.js');
+require('../base/connector/constants.js');
+require('jwt-decode');
+require('../base/plugin/errors.js');
+require('../base/plugin/IPlugin.js');
+var useWeb3AuthInner = require('../react/hooks/useWeb3AuthInner.js');
+var rest = require('./rest.js');
+
+const useLinkAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [linkedAccounts, setLinkedAccounts] = react.useState([]);
+  const linkAccount = react.useCallback(async params => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await web3Auth.linkAccount(params);
+      setLinkedAccounts(result.linkedAccounts);
+      return result;
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  const unlinkAccount = react.useCallback(async address => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await web3Auth.unlinkAccount(address);
+      setLinkedAccounts(result.linkedAccounts);
+      return result;
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    linkAccount,
+    unlinkAccount,
+    linkedAccounts
+  };
+};
+const useSwitchAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const switchAccount = react.useCallback(async account => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.switchAccount(account);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    switchAccount
+  };
+};
+
+exports.makeAccountLinkingRequest = rest.makeAccountLinkingRequest;
+exports.makeAccountUnlinkingRequest = rest.makeAccountUnlinkingRequest;
+exports.useLinkAccount = useLinkAccount;
+exports.useSwitchAccount = useSwitchAccount;

package/dist/lib.cjs/account-linking/rest.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var httpHelpers = require('@toruslabs/http-helpers');
+var index = require('../base/errors/index.js');
+
+/**
+ * Send both identity proofs to the Citadel account-linking endpoint and
+ * return a normalized result.
+ *
+ * Throws AccountLinkingError when the server returns an error or the request itself fails.
+ */
+async function makeAccountLinkingRequest(authServerUrl, accessToken, payload) {
+  const url = `${authServerUrl}/v1/link/wallet`;
+  let result;
+  try {
+    result = await httpHelpers.post(url, payload, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw index.AccountLinkingError.requestFailed(message, cause);
+  }
+  if (!result.success) {
+    var _result$message;
+    const errMessage = (_result$message = result.message) !== null && _result$message !== void 0 ? _result$message : "Failed to link account";
+    throw index.AccountLinkingError.requestFailed(errMessage);
+  }
+  return result;
+}
+async function makeAccountUnlinkingRequest(authServerUrl, accessToken, payload) {
+  const url = `${authServerUrl}/v1/unlink`;
+  let result;
+  try {
+    result = await httpHelpers.post(url, payload, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw index.AccountLinkingError.requestFailed(message, cause);
+  }
+  if (!result.success) {
+    var _result$message2;
+    const errMessage = (_result$message2 = result.message) !== null && _result$message2 !== void 0 ? _result$message2 : "Failed to unlink account";
+    throw index.AccountLinkingError.requestFailed(errMessage);
+  }
+  return result;
+}
+
+exports.makeAccountLinkingRequest = makeAccountLinkingRequest;
+exports.makeAccountUnlinkingRequest = makeAccountUnlinkingRequest;

package/dist/lib.cjs/account-linking/vue.js

@@ -0,0 +1,98 @@
+'use strict';
+
+var vue = require('vue');
+require('@babel/runtime/helpers/objectSpread2');
+require('@babel/runtime/helpers/defineProperty');
+require('@segment/analytics-next');
+var loglevel = require('../base/loglevel.js');
+require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
+require('@web3auth/auth');
+var index = require('../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../base/constants.js');
+require('../base/wallet/index.js');
+require('../base/connector/connectorStatus.js');
+require('../base/connector/constants.js');
+require('jwt-decode');
+require('../base/plugin/errors.js');
+require('../base/plugin/IPlugin.js');
+var useWeb3AuthInner = require('../vue/composables/useWeb3AuthInner.js');
+var rest = require('./rest.js');
+
+const useLinkAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const linkedAccounts = vue.ref([]);
+  const linkAccount = async params => {
+    if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+    try {
+      error.value = null;
+      loading.value = true;
+      const result = await web3Auth.value.linkAccount(params);
+      linkedAccounts.value = result.linkedAccounts;
+      return result;
+    } catch (err) {
+      loglevel.log.error("Error linking account", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const unlinkAccount = async address => {
+    if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+    try {
+      error.value = null;
+      loading.value = true;
+      const result = await web3Auth.value.unlinkAccount(address);
+      linkedAccounts.value = result.linkedAccounts;
+      return result;
+    } catch (err) {
+      loglevel.log.error("Error unlinking account", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    linkAccount,
+    unlinkAccount,
+    linkedAccounts
+  };
+};
+const useSwitchAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const switchAccount = async account => {
+    if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+    error.value = null;
+    loading.value = true;
+    try {
+      await web3Auth.value.switchAccount(account);
+    } catch (err) {
+      loglevel.log.error("Error switching account", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    switchAccount
+  };
+};
+
+exports.makeAccountLinkingRequest = rest.makeAccountLinkingRequest;
+exports.makeAccountUnlinkingRequest = rest.makeAccountUnlinkingRequest;
+exports.useLinkAccount = useLinkAccount;
+exports.useSwitchAccount = useSwitchAccount;

package/dist/lib.cjs/base/analytics.js

@@ -119,7 +119,19 @@ const ANALYTICS_EVENTS = {
   WALLET_FUNDING_CLICKED: "Wallet Funding Clicked",
   WALLET_CHECKOUT_CLICKED: "Wallet Checkout Clicked",
   WALLET_RECEIVE_CLICKED: "Wallet Receive Clicked",
-  WALLET_SWAP_CLICKED: "Wallet Swap Clicked"
+  WALLET_SWAP_CLICKED: "Wallet Swap Clicked",
+  // Account Linking
+  ACCOUNT_LINKING_STARTED: "Account Linking Started",
+  ACCOUNT_LINKING_COMPLETED: "Account Linking Completed",
+  ACCOUNT_LINKING_FAILED: "Account Linking Failed",
+  // Account Unlinking
+  ACCOUNT_UNLINKING_STARTED: "Account Unlinking Started",
+  ACCOUNT_UNLINKING_COMPLETED: "Account Unlinking Completed",
+  ACCOUNT_UNLINKING_FAILED: "Account Unlinking Failed",
+  // Account switch (active connected wallet)
+  ACCOUNT_SWITCH_STARTED: "Account Switch Started",
+  ACCOUNT_SWITCH_COMPLETED: "Account Switch Completed",
+  ACCOUNT_SWITCH_FAILED: "Account Switch Failed"
 };
 const ANALYTICS_INTEGRATION_TYPE = {
   REACT_HOOKS: "React Hooks",

package/dist/lib.cjs/base/connector/baseConnector.js

@@ -1,13 +1,17 @@
 'use strict';
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var sessionManager = require('@toruslabs/session-manager');
 var auth = require('@web3auth/auth');
 var IChainInterface = require('../chain/IChainInterface.js');
 var index$1 = require('../errors/index.js');
+var loglevel = require('../loglevel.js');
+var utils = require('../utils.js');
 var index = require('../wallet/index.js');
 var connectorStatus = require('./connectorStatus.js');
 var constants = require('./constants.js');
-var baseControllers = require('@toruslabs/base-controllers');
+var utils$1 = require('./utils.js');
 
 class BaseConnector extends auth.SafeEventEmitter {
   constructor(options) {
@@ -17,6 +21,7 @@ class BaseConnector extends auth.SafeEventEmitter {
     _defineProperty(this, "icon", void 0);
     _defineProperty(this, "coreOptions", void 0);
     _defineProperty(this, "rehydrated", false);
+    _defineProperty(this, "authSessionManager", null);
     this.coreOptions = options.coreOptions;
   }
   get connected() {
@@ -25,6 +30,12 @@ class BaseConnector extends auth.SafeEventEmitter {
   get canAuthorize() {
     return connectorStatus.CAN_AUTHORIZE_STATUSES.includes(this.status);
   }
+  get solanaWallet() {
+    return null;
+  }
+  get provider() {
+    return null;
+  }
   checkConnectionRequirements() {
     // we reconnect without killing existing Wallet Connect or Metamask Connect session on calling connect again.
     if (this.name === index.WALLET_CONNECTORS.WALLET_CONNECT_V2 && this.status === constants.CONNECTOR_STATUS.CONNECTING) return;
@@ -53,7 +64,7 @@ class BaseConnector extends auth.SafeEventEmitter {
     if (!this.connected) throw index$1.WalletLoginError.disconnectionError("Not connected with wallet");
   }
   checkSwitchChainRequirements(params, init = false) {
-    if (!init && !this.provider) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet.");
+    if (!init && !this.provider && !this.solanaWallet) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet.");
     if (!this.coreOptions.chains) throw index$1.WalletInitializationError.invalidParams("chainConfigs is required");
     const doesChainExist = this.coreOptions.chains.some(x => x.chainId === params.chainId && (x.chainNamespace === this.connectorNamespace || this.connectorNamespace === IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN));
     if (!doesChainExist) throw index$1.WalletInitializationError.invalidParams("Invalid chainId");
@@ -65,6 +76,97 @@ class BaseConnector extends auth.SafeEventEmitter {
       data
     });
   }
+  initSessionManager(address) {
+    this.authSessionManager = new sessionManager.AuthSessionManager({
+      storageKeyPrefix: `w3a:siww:${this.name}:${address.toLowerCase()}`,
+      apiClientConfig: {
+        baseURL: utils.citadelServerUrl(this.coreOptions.authBuildEnv)
+      },
+      storage: this.coreOptions.storage,
+      cookieOptions: this.coreOptions.cookieOptions
+    });
+  }
+  async getCachedAuthTokenInfo() {
+    if (!this.authSessionManager) return null;
+    const idToken = await this.authSessionManager.getIdToken();
+    if (!idToken || utils$1.checkIfTokenIsExpired(idToken)) return null;
+    let [accessToken, refreshToken] = await Promise.all([this.authSessionManager.getAccessToken(), this.authSessionManager.getRefreshToken()]);
+    if ((!accessToken || utils$1.checkIfTokenIsExpired(accessToken)) && refreshToken) {
+      try {
+        const response = await this.authSessionManager.ensureRefresh();
+        accessToken = response.access_token || (await this.authSessionManager.getAccessToken());
+        refreshToken = response.refresh_token || refreshToken;
+      } catch {
+        // access token refresh failed; still return the valid idToken
+        loglevel.log.error("Access token refresh failed");
+      }
+    }
+    return {
+      idToken,
+      accessToken: accessToken !== null && accessToken !== void 0 ? accessToken : undefined,
+      refreshToken: refreshToken !== null && refreshToken !== void 0 ? refreshToken : undefined
+    };
+  }
+  async saveAuthTokenInfo(tokens) {
+    if (!this.authSessionManager) return;
+    await this.authSessionManager.setTokens({
+      idToken: tokens.idToken,
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken
+    });
+  }
+  async getCachedOrNullAuthTokenInfo(account) {
+    this.initSessionManager(account);
+    const cached = await this.getCachedAuthTokenInfo();
+    if (cached) {
+      this.status = constants.CONNECTOR_STATUS.AUTHORIZED;
+      this.emit(constants.CONNECTOR_EVENTS.AUTHORIZED, {
+        connector: this.name,
+        authTokenInfo: cached
+      });
+    }
+    return cached;
+  }
+  async verifyAndAuthorize(params) {
+    const tokens = await baseControllers.verifySignedChallenge({
+      chainNamespace: params.chainNamespace,
+      signedMessage: params.signedMessage,
+      challenge: params.challenge,
+      connector: this.name,
+      authServer: params.authServer,
+      web3AuthClientId: this.coreOptions.clientId,
+      web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+      sessionTimeout: this.coreOptions.sessionTime,
+      deviceInfo: baseControllers.getDeviceInfo()
+    });
+    await this.saveAuthTokenInfo(tokens);
+    const tokenInfo = {
+      idToken: tokens.idToken,
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken
+    };
+    this.status = constants.CONNECTOR_STATUS.AUTHORIZED;
+    this.emit(constants.CONNECTOR_EVENTS.AUTHORIZED, {
+      connector: this.name,
+      authTokenInfo: tokenInfo
+    });
+    return tokenInfo;
+  }
+  async clearWalletSession() {
+    if (!this.authSessionManager) return;
+    try {
+      await this.authSessionManager.logout();
+    } catch {
+      try {
+        await this.authSessionManager.clearSessionData();
+      } catch {
+        // best-effort cleanup; don't block disconnect
+        loglevel.log.error("Failed to clear wallet session");
+      }
+    } finally {
+      this.authSessionManager = null;
+    }
+  }
 }
 
 exports.BaseConnector = BaseConnector;

package/dist/lib.cjs/base/connector/connectorStatus.js

@@ -4,6 +4,8 @@ var constants = require('./constants.js');
 
 const CONNECTED_STATUSES = [constants.CONNECTOR_STATUS.CONNECTED, constants.CONNECTOR_STATUS.AUTHORIZED];
 const CAN_AUTHORIZE_STATUSES = [constants.CONNECTOR_STATUS.AUTHORIZING, constants.CONNECTOR_STATUS.AUTHORIZED, constants.CONNECTOR_STATUS.CONNECTED];
+const CAN_LOGOUT_STATUSES = [...CONNECTED_STATUSES, constants.CONNECTOR_STATUS.CONSENT_REQUIRING];
 
 exports.CAN_AUTHORIZE_STATUSES = CAN_AUTHORIZE_STATUSES;
+exports.CAN_LOGOUT_STATUSES = CAN_LOGOUT_STATUSES;
 exports.CONNECTED_STATUSES = CONNECTED_STATUSES;

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

@@ -11,14 +11,18 @@ const CONNECTOR_STATUS = {
   DISCONNECTED: "disconnected",
   ERRORED: "errored",
   AUTHORIZED: "authorized",
-  AUTHORIZING: "authorizing"
+  AUTHORIZING: "authorizing",
+  CONSENT_REQUIRING: "consent_requiring"
 };
 const CONNECTOR_EVENTS = _objectSpread(_objectSpread({}, CONNECTOR_STATUS), {}, {
   CONNECTOR_DATA_UPDATED: "connector_data_updated",
   CACHE_CLEAR: "cache_clear",
   CONNECTORS_UPDATED: "connectors_updated",
   MFA_ENABLED: "mfa_enabled",
-  REHYDRATION_ERROR: "rehydration_error"
+  REHYDRATION_ERROR: "rehydration_error",
+  /** Emitted when the active public `connection` changes without a full reconnect (e.g. account switch). */
+  CONNECTION_UPDATED: "connection_updated",
+  CONSENT_ACCEPTED: "consent_accepted"
 });
 const CONNECTOR_CATEGORY = {
   EXTERNAL: "external",

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

@@ -40,27 +40,6 @@ const checkIfTokenIsExpired = token => {
   }
   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/constants.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var ethereumControllers = require('@toruslabs/ethereum-controllers');
+
 const SMART_ACCOUNT_WALLET_SCOPE = {
   EMBEDDED: "embedded",
   ALL: "all"
@@ -23,8 +25,10 @@ const SOLANA_CAIP_CHAIN_MAP = {
   "0x66": "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z",
   "0x67": "EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
 };
+const EIP_7702_SUPPORTED_SMART_ACCOUNTS = [ethereumControllers.SMART_ACCOUNT.METAMASK];
 const WALLET_REGISTRY_URL = "https://assets.web3auth.io/v2/wallet-registry.json";
 
+exports.EIP_7702_SUPPORTED_SMART_ACCOUNTS = EIP_7702_SUPPORTED_SMART_ACCOUNTS;
 exports.LOGIN_MODE = LOGIN_MODE;
 exports.MODAL_SIGN_IN_METHODS = MODAL_SIGN_IN_METHODS;
 exports.SMART_ACCOUNT_WALLET_SCOPE = SMART_ACCOUNT_WALLET_SCOPE;

package/dist/lib.cjs/base/cookie.js

@@ -3,24 +3,6 @@
 var constants = require('./constants.js');
 var deserialize = require('./deserialize.js');
 
-const cookieStorage = options => ({
-  getItem(key) {
-    if (typeof window === "undefined") return null;
-    const value = parseCookie(document.cookie, key);
-    return value !== null && value !== void 0 ? value : null;
-  },
-  setItem(key, value) {
-    if (typeof window === "undefined") return;
-    let cookieString = `${key}=${value};path=/;samesite=Lax`;
-    if (options !== null && options !== void 0 && options.expiry && typeof options.expiry === "number") cookieString += `; expires=${new Date(Date.now() + options.expiry).toUTCString()}`;
-    if (process.env.NODE_ENV === "production") cookieString += "; secure";
-    document.cookie = cookieString;
-  },
-  removeItem(key) {
-    if (typeof window === "undefined") return;
-    document.cookie = `${key}=;max-age=-1;path=/`;
-  }
-});
 function cookieToWeb3AuthState(cookie) {
   if (!cookie) return undefined;
   const parsed = parseCookie(cookie, constants.WEB3AUTH_STATE_STORAGE_KEY);
@@ -30,9 +12,13 @@ function cookieToWeb3AuthState(cookie) {
 function parseCookie(cookie, key) {
   const keyValue = cookie.split("; ").find(x => x.startsWith(`${key}=`));
   if (!keyValue) return undefined;
-  return keyValue.substring(key.length + 1);
+  const value = keyValue.substring(key.length + 1);
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
 }
 
-exports.cookieStorage = cookieStorage;
 exports.cookieToWeb3AuthState = cookieToWeb3AuthState;
 exports.parseCookie = parseCookie;