@web3auth/no-modal 10.0.0-beta.1 → 10.0.0-beta.10

package/dist/lib.cjs/vue/wagmi/provider.js

@@ -0,0 +1,244 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var core = require('@wagmi/core');
+var vue$1 = require('@wagmi/vue');
+var connectors = require('@wagmi/vue/connectors');
+var auth = require('@web3auth/auth');
+var viem = require('viem');
+var vue = require('vue');
+var baseControllers = require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+var index = require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+var loglevel = require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var useWeb3Auth = require('../composables/useWeb3Auth.js');
+var useWeb3AuthDisconnect = require('../composables/useWeb3AuthDisconnect.js');
+var constants = require('./constants.js');
+
+const WEB3AUTH_CONNECTOR_ID = "web3auth";
+// Helper to initialize connectors for the given wallets
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function setupConnector(provider, config) {
+  let connector = config.connectors.find(c => c.id === WEB3AUTH_CONNECTOR_ID);
+  if (connector) return connector;
+  // Create new connector if not already existing
+  connector = connectors.injected({
+    target: {
+      provider: provider,
+      id: WEB3AUTH_CONNECTOR_ID,
+      name: "Web3Auth"
+    }
+  });
+  const result = config._internal.connectors.setup(connector);
+  config._internal.connectors.setState(current => [...current, result]);
+  return result;
+}
+// Helper to connect a wallet and update wagmi state
+async function connectWeb3AuthWithWagmi(connector, config) {
+  var _config$storage, _config$storage2;
+  await Promise.all([(_config$storage = config.storage) === null || _config$storage === void 0 ? void 0 : _config$storage.removeItem(`${connector.id}.disconnected`), (_config$storage2 = config.storage) === null || _config$storage2 === void 0 ? void 0 : _config$storage2.setItem("recentConnectorId", connector.id)]);
+  let chainId = await connector.getChainId();
+  if (!config.chains.find(c => c.id === chainId)) {
+    chainId = config.chains[0].id;
+  }
+  const accounts = await connector.getAccounts();
+  const connections = new Map([[connector.uid, {
+    accounts: [accounts[0]],
+    chainId,
+    connector
+  }]]);
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId,
+    connections,
+    current: connector.uid,
+    status: "connected"
+  }));
+}
+async function disconnectWeb3AuthFromWagmi(config) {
+  config._internal.connectors.setState(prev => prev.filter(c => c.id !== WEB3AUTH_CONNECTOR_ID));
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId: state.chainId,
+    connections: new Map(),
+    current: undefined,
+    status: "disconnected"
+  }));
+}
+const Web3AuthWagmiProvider = vue.defineComponent({
+  name: "Web3AuthWagmiProvider",
+  setup() {
+    const {
+      isConnected,
+      provider
+    } = useWeb3Auth.useWeb3Auth();
+    const {
+      disconnect
+    } = useWeb3AuthDisconnect.useWeb3AuthDisconnect();
+    const wagmiConfig = vue$1.useConfig();
+    const {
+      reconnect
+    } = vue$1.useReconnect();
+    vue$1.useAccountEffect({
+      onDisconnect: async () => {
+        loglevel.log.info("Disconnected from wagmi");
+        if (isConnected.value) await disconnect();
+      }
+    });
+    vue.watch(isConnected, async newIsConnected => {
+      if (newIsConnected && provider.value) {
+        const connector = await setupConnector(provider.value, wagmiConfig);
+        if (!connector) {
+          throw new Error("Failed to setup connector");
+        }
+        await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+        reconnect();
+      } else if (!newIsConnected) {
+        if (wagmiConfig.state.status === "connected") {
+          await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        }
+      }
+    }, {
+      immediate: true
+    });
+  },
+  render() {
+    var _this$$slots$default;
+    return vue.h((_this$$slots$default = this.$slots.default) !== null && _this$$slots$default !== void 0 ? _this$$slots$default : "");
+  }
+});
+const Web3AuthWagmiInnerProvider = vue.defineComponent({
+  name: "Web3AuthWagmiInnerProvider",
+  props: {
+    config: {
+      type: Object,
+      required: false
+    }
+  },
+  setup(props) {
+    const {
+      config
+    } = props;
+    vue.provide(vue$1.configKey, config);
+  },
+  render() {
+    var _this$$slots$default2;
+    return vue.h(Web3AuthWagmiProvider, {}, (_this$$slots$default2 = this.$slots.default) !== null && _this$$slots$default2 !== void 0 ? _this$$slots$default2 : "");
+  }
+});
+const WagmiProvider = vue.defineComponent({
+  name: "WagmiProvider",
+  props: {
+    config: {
+      type: Object,
+      required: false
+    }
+  },
+  setup(props) {
+    const {
+      config
+    } = props;
+    const {
+      web3Auth,
+      isInitialized
+    } = useWeb3Auth.useWeb3Auth();
+    const finalConfig = vue.shallowRef(constants.defaultWagmiConfig);
+    const configKey = vue.ref(auth.randomId());
+    const defineWagmiConfig = () => {
+      var _web3Auth$value;
+      const configParams = _objectSpread(_objectSpread({
+        ssr: true
+      }, config), {}, {
+        chains: undefined,
+        connectors: [],
+        transports: {},
+        multiInjectedProviderDiscovery: false,
+        client: undefined
+      });
+      const wagmiChains = [];
+      if (isInitialized.value && web3Auth !== null && web3Auth !== void 0 && (_web3Auth$value = web3Auth.value) !== null && _web3Auth$value !== void 0 && (_web3Auth$value = _web3Auth$value.coreOptions) !== null && _web3Auth$value !== void 0 && _web3Auth$value.chains) {
+        var _web3Auth$value$curre;
+        const defaultChainId = (_web3Auth$value$curre = web3Auth.value.currentChain) === null || _web3Auth$value$curre === void 0 ? void 0 : _web3Auth$value$curre.chainId;
+        const chains = web3Auth.value.coreOptions.chains.filter(chain => chain.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155);
+        if (chains.length === 0) throw index.WalletInitializationError.invalidParams("No valid chains found in web3auth config for wagmi.");
+        chains.forEach(chain => {
+          const wagmiChain = viem.defineChain({
+            id: Number.parseInt(chain.chainId, 16),
+            // id in number form
+            name: chain.displayName,
+            rpcUrls: {
+              default: {
+                http: [chain.rpcTarget],
+                webSocket: [chain.wsTarget]
+              }
+            },
+            blockExplorers: chain.blockExplorerUrl ? {
+              default: {
+                name: "explorer",
+                // TODO: correct name if chain config has it
+                url: chain.blockExplorerUrl
+              }
+            } : undefined,
+            nativeCurrency: {
+              name: chain.tickerName,
+              symbol: chain.ticker,
+              decimals: chain.decimals || 18
+            }
+          });
+          if (defaultChainId === chain.chainId) {
+            wagmiChains.unshift(wagmiChain);
+          } else {
+            wagmiChains.push(wagmiChain);
+          }
+          configParams.transports[wagmiChain.id] = chain.wsTarget ? viem.webSocket(chain.wsTarget) : viem.http(chain.rpcTarget);
+        });
+        configParams.chains = [wagmiChains[0], ...wagmiChains.slice(1)];
+      }
+      return vue$1.createConfig(configParams);
+    };
+    const hydrateWagmiConfig = () => {
+      if (finalConfig.value) {
+        core.hydrate(finalConfig.value, _objectSpread({
+          reconnectOnMount: false
+        }, props.config));
+      }
+    };
+    vue.watch(isInitialized, newIsInitialized => {
+      if (newIsInitialized && !finalConfig.value) {
+        finalConfig.value = defineWagmiConfig();
+        hydrateWagmiConfig();
+        configKey.value = auth.randomId();
+      }
+    }, {
+      immediate: true
+    });
+    if (!isInitialized.value) {
+      hydrateWagmiConfig();
+    }
+    return {
+      finalConfig,
+      configKey
+    };
+  },
+  render() {
+    if (!this.finalConfig) return null;
+    return vue.h(Web3AuthWagmiInnerProvider,
+    // This key is used to remount the provider when the config changes.
+    {
+      config: this.finalConfig,
+      key: this.configKey
+    }, {
+      default: () => {
+        var _this$$slots$default3, _this$$slots;
+        return (_this$$slots$default3 = (_this$$slots = this.$slots).default) === null || _this$$slots$default3 === void 0 ? void 0 : _this$$slots$default3.call(_this$$slots);
+      }
+    });
+  }
+});
+
+exports.WagmiProvider = WagmiProvider;

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

@@ -14,14 +14,19 @@ class BaseConnector extends SafeEventEmitter {
     _defineProperty(this, "icon", void 0);
     _defineProperty(this, "coreOptions", void 0);
     _defineProperty(this, "rehydrated", false);
+    _defineProperty(this, "connectorNamespace", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "status", void 0);
     this.coreOptions = options.coreOptions;
   }
   get connnected() {
     return this.status === CONNECTOR_STATUS.CONNECTED;
   }
   checkConnectionRequirements() {
-    // we reconnect without killing existing wallet connect session on calling connect again.
+    // we reconnect without killing existing Wallet Connect or Metamask Connect session on calling connect again.
     if (this.name === WALLET_CONNECTORS.WALLET_CONNECT_V2 && this.status === CONNECTOR_STATUS.CONNECTING) return;
+    if (this.name === WALLET_CONNECTORS.METAMASK && !this.isInjected && this.status === CONNECTOR_STATUS.CONNECTING) return;
     if (this.status === CONNECTOR_STATUS.CONNECTING) throw WalletInitializationError.notReady("Already connecting");
     if (this.status === CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.connectionError("Already connected");
     if (this.status !== CONNECTOR_STATUS.READY) throw WalletLoginError.connectionError("Wallet connector is not ready yet, Please wait for init function to resolve before calling connect/connectTo function");

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

@@ -12,7 +12,9 @@ const CONNECTOR_STATUS = {
 const CONNECTOR_EVENTS = _objectSpread(_objectSpread({}, CONNECTOR_STATUS), {}, {
   CONNECTOR_DATA_UPDATED: "connector_data_updated",
   CACHE_CLEAR: "cache_clear",
-  CONNECTORS_UPDATED: "connectors_updated"
+  CONNECTORS_UPDATED: "connectors_updated",
+  MFA_ENABLED: "mfa_enabled",
+  REHYDRATION_ERROR: "rehydration_error"
 });
 const CONNECTOR_CATEGORY = {
   EXTERNAL: "external",

package/dist/lib.esm/base/constants.js

@@ -11,5 +11,10 @@ const WIDGET_TYPE = {
   MODAL: "modal",
   EMBED: "embed"
 };
+const WEB3AUTH_STATE_STORAGE_KEY = "Web3Auth-state";
+const LOGIN_MODE = {
+  MODAL: "modal",
+  NO_MODAL: "no-modal"
+};
 
-export { MODAL_SIGN_IN_METHODS, SMART_ACCOUNT_WALLET_SCOPE, WIDGET_TYPE };
+export { LOGIN_MODE, MODAL_SIGN_IN_METHODS, SMART_ACCOUNT_WALLET_SCOPE, WEB3AUTH_STATE_STORAGE_KEY, WIDGET_TYPE };

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

@@ -0,0 +1,34 @@
+import { WEB3AUTH_STATE_STORAGE_KEY } from './constants.js';
+import { deserialize } from './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, WEB3AUTH_STATE_STORAGE_KEY);
+  if (!parsed) return undefined;
+  return deserialize(parsed);
+}
+function parseCookie(cookie, key) {
+  const keyValue = cookie.split("; ").find(x => x.startsWith(`${key}=`));
+  if (!keyValue) return undefined;
+  return keyValue.substring(key.length + 1);
+}
+
+export { cookieStorage, cookieToWeb3AuthState, parseCookie };

package/dist/lib.esm/base/deserialize.js

@@ -0,0 +1,11 @@
+function deserialize(value, reviver) {
+  return JSON.parse(value, (key, value_) => {
+    var _value, _value2, _reviver;
+    let value = value_;
+    if (((_value = value) === null || _value === void 0 ? void 0 : _value.__type) === "bigint") value = BigInt(value.value);
+    if (((_value2 = value) === null || _value2 === void 0 ? void 0 : _value2.__type) === "Map") value = new Map(value.value);
+    return (_reviver = void 0 ) !== null && _reviver !== void 0 ? _reviver : value;
+  });
+}
+
+export { deserialize };

package/dist/lib.esm/base/errors/index.js

@@ -1,24 +1,8 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { CustomError } from 'ts-custom-error';
 
-function serializeError(args) {
-  // Find first Error or create an "unknown" Error to keep stack trace.
-  const index = args.findIndex(arg => arg instanceof Error);
-  const msgIndex = args.findIndex(arg => typeof arg === "string");
-  const apiErrorIdx = args.findIndex(arg => arg && typeof arg === "object" && "status" in arg && "type" in arg);
-  let err;
-  if (apiErrorIdx !== -1) {
-    const apiError = args[apiErrorIdx];
-    err = new Error(`${apiError.status} ${apiError.type.toString()} ${apiError.statusText}`);
-  } else if (index !== -1) {
-    err = args.splice(index, 1)[0];
-  } else if (msgIndex !== -1) {
-    err = new Error(args.splice(msgIndex, 1)[0]);
-  } else {
-    err = new Error("Unknown error");
-  }
-  return [err, args];
-}
+// @flow
+
 class Web3AuthError extends CustomError {
   constructor(code, message, cause) {
     // takes care of stack and proto
@@ -39,7 +23,7 @@ class Web3AuthError extends CustomError {
       name: this.name,
       code: this.code,
       message: this.message,
-      cause: serializeError([this.cause])
+      cause: this.cause
     };
   }
   toString() {
@@ -50,6 +34,7 @@ class WalletInitializationError extends Web3AuthError {
   constructor(code, message, cause) {
     // takes care of stack and proto
     super(code, message, cause);
+
     // Set name explicitly as minification can mangle class names
     Object.defineProperty(this, "name", {
       value: "WalletInitializationError"
@@ -58,6 +43,7 @@ class WalletInitializationError extends Web3AuthError {
   static fromCode(code, extraMessage = "", cause) {
     return new WalletInitializationError(code, `${WalletInitializationError.messages[code]}, ${extraMessage}`, cause);
   }
+
   // Custom methods
   static notFound(extraMessage = "", cause) {
     return WalletInitializationError.fromCode(5001, extraMessage, cause);
@@ -96,6 +82,7 @@ class WalletInitializationError extends Web3AuthError {
     return WalletInitializationError.fromCode(5013, extraMessage, cause);
   }
 }
+
 /**
  * wallet login errors
  */
@@ -118,6 +105,7 @@ class WalletLoginError extends Web3AuthError {
   constructor(code, message, cause) {
     // takes care of stack and proto
     super(code, message, cause);
+
     // Set name explicitly as minification can mangle class names
     Object.defineProperty(this, "name", {
       value: "WalletLoginError"
@@ -147,7 +135,7 @@ class WalletLoginError extends Web3AuthError {
   static unsupportedOperation(extraMessage = "", cause) {
     return WalletLoginError.fromCode(5117, extraMessage, cause);
   }
-  static coreKitKeyNotFound(extraMessage = "", cause) {
+  static sfaKeyNotFound(extraMessage = "", cause) {
     return WalletLoginError.fromCode(5118, extraMessage, cause);
   }
   static userNotLoggedIn(extraMessage = "", cause) {
@@ -163,13 +151,14 @@ _defineProperty(WalletLoginError, "messages", {
   5115: "User has already enabled mfa, please use the @web3auth/web3auth-web sdk for login with mfa",
   5116: "Chain config has not been added. Please add the chain config before calling switchChain",
   5117: "Unsupported operation",
-  5118: "useCoreKitKey flag is enabled but coreKitKey is not available",
+  5118: "useSFAKey flag is enabled but SFA key is not available",
   5119: "User not logged in."
 });
 class WalletOperationsError extends Web3AuthError {
   constructor(code, message, cause) {
     // takes care of stack and proto
     super(code, message, cause);
+
     // Set name explicitly as minification can mangle class names
     Object.defineProperty(this, "name", {
       value: "WalletOperationsError"
@@ -178,6 +167,7 @@ class WalletOperationsError extends Web3AuthError {
   static fromCode(code, extraMessage = "", cause) {
     return new WalletOperationsError(code, `${WalletOperationsError.messages[code]}, ${extraMessage}`, cause);
   }
+
   // Custom methods
   static chainIDNotAllowed(extraMessage = "", cause) {
     return WalletOperationsError.fromCode(5201, extraMessage, cause);
@@ -198,6 +188,7 @@ class WalletProviderError extends Web3AuthError {
   constructor(code, message, cause) {
     // takes care of stack and proto
     super(code, message, cause);
+
     // Set name explicitly as minification can mangle class names
     Object.defineProperty(this, "name", {
       value: "WalletProviderError"
@@ -206,6 +197,7 @@ class WalletProviderError extends Web3AuthError {
   static fromCode(code, extraMessage = "", cause) {
     return new WalletOperationsError(code, `${WalletProviderError.messages[code]}, ${extraMessage}`, cause);
   }
+
   // Custom methods
   static invalidRequestArgs(extraMessage = "", cause) {
     return WalletOperationsError.fromCode(5301, extraMessage, cause);
@@ -224,4 +216,4 @@ _defineProperty(WalletProviderError, "messages", {
   5303: "'args.params' must be an object or array if provided."
 });
 
-export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError, serializeError };
+export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError };

package/dist/lib.esm/base/plugin/errors.js

@@ -5,6 +5,7 @@ class WalletServicesPluginError extends Web3AuthError {
   constructor(code, message, cause) {
     // takes care of stack and proto
     super(code, message, cause);
+
     // Set name explicitly as minification can mangle class names
     Object.defineProperty(this, "name", {
       value: "WalletServicesPluginError"
@@ -67,6 +68,7 @@ class NFTCheckoutPluginError extends Web3AuthError {
   constructor(code, message, cause) {
     // takes care of stack and proto
     super(code, message, cause);
+
     // Set name explicitly as minification can mangle class names
     Object.defineProperty(this, "name", {
       value: "NFTCheckoutPluginError"

package/dist/lib.esm/base/utils.js

@@ -2,18 +2,16 @@ import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 export { cloneDeep } from '@toruslabs/base-controllers';
 import { SIGNER_MAP } from '@toruslabs/constants';
 import { get } from '@toruslabs/http-helpers';
-import '@babel/runtime/helpers/defineProperty';
-import { WEB3AUTH_NETWORK } from '@web3auth/auth';
-import './errors/index.js';
-import './wallet/index.js';
-import './connector/constants.js';
-import 'jwt-decode';
+import { WEB3AUTH_NETWORK, BUILD_ENV } from '@web3auth/auth';
 
 const isHexStrict = hex => {
   return (typeof hex === "string" || typeof hex === "number") && /^(-)?0x[0-9a-f]*$/i.test(hex);
 };
-const signerHost = web3AuthNetwork => {
-  return SIGNER_MAP[web3AuthNetwork !== null && web3AuthNetwork !== void 0 ? web3AuthNetwork : WEB3AUTH_NETWORK.SAPPHIRE_MAINNET];
+const signerHost = (web3AuthNetwork = WEB3AUTH_NETWORK.SAPPHIRE_MAINNET, authBuildEnv = BUILD_ENV.PRODUCTION) => {
+  if (authBuildEnv === BUILD_ENV.TESTING || authBuildEnv === BUILD_ENV.DEVELOPMENT) {
+    return "https://test-signer.web3auth.io";
+  }
+  return SIGNER_MAP[web3AuthNetwork];
 };
 const fetchProjectConfig = async ({
   clientId,
@@ -21,9 +19,7 @@ const fetchProjectConfig = async ({
   aaProvider,
   authBuildEnv
 }) => {
-  // const url = new URL(`${signerHost(web3AuthNetwork)}/api/v2/configuration`);
-  // TODO: remove this before production
-  const url = new URL("https://test-signer.web3auth.io/api/v2/configuration");
+  const url = new URL(`${signerHost(web3AuthNetwork, authBuildEnv)}/api/v2/configuration`);
   url.searchParams.append("project_id", clientId);
   url.searchParams.append("network", web3AuthNetwork);
   if (authBuildEnv) url.searchParams.append("build_env", authBuildEnv);
@@ -35,17 +31,22 @@ const fetchWalletRegistry = async url => {
   const res = await get(url || "https://assets.web3auth.io/v1/wallet-registry.json");
   return res;
 };
+
 // Normalize wallet name to a standard format, used for external wallets that are auto-detected by MIPD (EIP-6963 and Wallet Standard)
 const normalizeWalletName = name => {
   let normalizedName = name.toLowerCase();
   // remove decriptive part after | e.g. "Crypto.com | Defi Wallet" => "Crypto.com"
   normalizedName = normalizedName.split("|")[0];
+
   // replace -  with space e.g. "Trust - Wallet" => "Trust Wallet"
   normalizedName = normalizedName.replace(/-/g, " ");
+
   // replace multiple spaces with single space
   normalizedName = normalizedName.replace(/\s+/g, " ");
+
   // remove trailing "wallet" e.g. "Trust Wallet" => "Trust", "GateWallet" => "Gate"
   normalizedName = normalizedName.replace(/wallet$/i, "").trim();
+
   // replace space with -
   normalizedName = normalizedName.replace(/\s/g, "-");
   return normalizedName;
@@ -66,6 +67,21 @@ const fromWagmiChain = chain => {
     wsTarget: (_chain$rpcUrls$defaul = chain.rpcUrls.default.webSocket) === null || _chain$rpcUrls$defaul === void 0 ? void 0 : _chain$rpcUrls$defaul[0]
   };
 };
+function withAbort(fn, signal, onAbort) {
+  if (!signal) return fn();
+  if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      onAbort === null || onAbort === void 0 || onAbort();
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", abort);
+    return Promise.resolve().then(() => fn()).then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", abort);
+    });
+  });
+}
+const isBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
 const fromViemChain = fromWagmiChain;
 
-export { fetchProjectConfig, fetchWalletRegistry, fromViemChain, fromWagmiChain, isHexStrict, normalizeWalletName, signerHost };
+export { fetchProjectConfig, fetchWalletRegistry, fromViemChain, fromWagmiChain, isBrowser, isHexStrict, normalizeWalletName, signerHost, withAbort };

package/dist/lib.esm/base/wallet/index.js

@@ -3,18 +3,16 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 const MULTI_CHAIN_CONNECTORS = {
   AUTH: "auth",
   WALLET_CONNECT_V2: "wallet-connect-v2",
-  SFA: "sfa"
+  METAMASK: "metamask"
 };
 const SOLANA_CONNECTORS = _objectSpread({}, MULTI_CHAIN_CONNECTORS);
 const EVM_CONNECTORS = _objectSpread({
-  COINBASE: "coinbase",
-  METAMASK: "metamask"
+  COINBASE: "coinbase"
 }, MULTI_CHAIN_CONNECTORS);
 const WALLET_CONNECTORS = _objectSpread(_objectSpread({}, EVM_CONNECTORS), SOLANA_CONNECTORS);
 const CONNECTOR_NAMES = {
   [MULTI_CHAIN_CONNECTORS.AUTH]: "Auth",
   [MULTI_CHAIN_CONNECTORS.WALLET_CONNECT_V2]: "Wallet Connect v2",
-  [MULTI_CHAIN_CONNECTORS.SFA]: "SFA",
   [EVM_CONNECTORS.COINBASE]: "Coinbase Smart Wallet",
   [EVM_CONNECTORS.METAMASK]: "MetaMask"
 };