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

package/dist/lib.cjs/providers/xrpl-provider/providers/privateKeyProviders/xrplWalletUtils.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var auth = require('@web3auth/auth');
+var rippleKeypairs = require('ripple-keypairs');
+var xrpl = require('xrpl');
+var ECDSA = require('xrpl/dist/npm/ECDSA');
+
+const deriveKeypair = web3authKey => {
+  const seed = rippleKeypairs.generateSeed({
+    entropy: Buffer.from(web3authKey.padStart(64, "0"), "hex"),
+    algorithm: "ecdsa-secp256k1"
+  });
+  const wallet = xrpl.Wallet.fromSecret(seed, {
+    algorithm: ECDSA.secp256k1
+  }); // web3auth network currently only supports the secp256k1 key
+  return {
+    privateKey: wallet.privateKey,
+    publicKey: wallet.publicKey
+  };
+};
+async function getProviderHandlers({
+  privKey: web3authKey,
+  chainConfig,
+  keyExportEnabled
+}) {
+  const client = new xrpl.Client(chainConfig.wsTarget);
+  await client.connect();
+  return {
+    getAccounts: async _ => {
+      const {
+        publicKey
+      } = deriveKeypair(web3authKey);
+      const accAddress = xrpl.deriveAddress(publicKey);
+      return [accAddress];
+    },
+    getKeyPair: async _ => {
+      if (!keyExportEnabled) throw auth.providerErrors.custom({
+        message: "Private key export is disabled",
+        code: 4902
+      });
+      return deriveKeypair(web3authKey);
+    },
+    getPublicKey: async _ => {
+      const keyPair = deriveKeypair(web3authKey);
+      return keyPair.publicKey;
+    },
+    signTransaction: async req => {
+      const {
+        transaction,
+        multisign
+      } = req.params || {};
+      if (!transaction) throw auth.rpcErrors.invalidParams("Invalid params, req.params.transaction is required");
+      const {
+        publicKey,
+        privateKey
+      } = deriveKeypair(web3authKey);
+      const wallet = new xrpl.Wallet(publicKey, privateKey);
+      return wallet.sign(transaction, multisign);
+    },
+    submitTransaction: async req => {
+      const {
+        transaction
+      } = req.params || {};
+      if (!transaction) throw auth.rpcErrors.invalidParams("Invalid params, req.params.transaction is required");
+      const {
+        publicKey,
+        privateKey
+      } = deriveKeypair(web3authKey);
+      const wallet = new xrpl.Wallet(publicKey, privateKey);
+      const res = await client.submit(transaction, {
+        wallet
+      });
+      return res;
+    },
+    signMessage: async req => {
+      const {
+        message
+      } = req.params || {};
+      if (!message) throw auth.rpcErrors.invalidParams("Invalid params, req.params.message is required");
+      const keyPair = deriveKeypair(web3authKey);
+      const signature = rippleKeypairs.sign(message, keyPair.privateKey);
+      return {
+        signature
+      };
+    }
+  };
+}
+
+exports.getProviderHandlers = getProviderHandlers;

package/dist/lib.cjs/providers/xrpl-provider/rpc/JrpcClient.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var xrplRpcMiddlewares = require('./xrplRpcMiddlewares.js');
+
+function createXrplChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === xrplRpcMiddlewares.RPC_METHODS.CHAIN_ID) {
+      res.result = chainId;
+      return end();
+    }
+    return next();
+  };
+}
+function createXrplProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === xrplRpcMiddlewares.RPC_METHODS.PROVIDER_CHAIN_CONFIG) {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createConfigMiddleware(providerConfig) {
+  const {
+    chainId
+  } = providerConfig;
+  return auth.mergeMiddleware([createXrplChainIdMiddleware(chainId), createXrplProviderConfigMiddleware(providerConfig)]);
+}
+function createXrplJsonRpcClient(providerConfig) {
+  const {
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = baseControllers.createFetchMiddleware({
+    rpcTarget
+  });
+  const networkMiddleware = auth.mergeMiddleware([createConfigMiddleware(providerConfig), fetchMiddleware]);
+  return {
+    networkMiddleware,
+    fetchMiddleware
+  };
+}
+
+exports.createConfigMiddleware = createConfigMiddleware;
+exports.createXrplChainIdMiddleware = createXrplChainIdMiddleware;
+exports.createXrplJsonRpcClient = createXrplJsonRpcClient;
+exports.createXrplProviderConfigMiddleware = createXrplProviderConfigMiddleware;

package/dist/lib.cjs/providers/xrpl-provider/rpc/xrplRpcMiddlewares.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+
+const RPC_METHODS = {
+  GET_ACCOUNTS: "xrpl_getAccounts",
+  GET_KEY_PAIR: "xrpl_getKeyPair",
+  GET_PUBLIC_KEY: "xrpl_getPublicKey",
+  SIGN_MESSAGE: "xrpl_signMessage",
+  SIGN_TRANSACTION: "xrpl_signTransaction",
+  SUBMIT_TRANSACTION: "xrpl_submitTransaction",
+  ADD_CHAIN: "xrpl_addChain",
+  SWITCH_CHAIN: "xrpl_switchChain",
+  CHAIN_ID: "xrpl_chainId",
+  PROVIDER_CHAIN_CONFIG: "xrpl_providerChainConfig"
+};
+function createGetAccountsMiddleware({
+  getAccounts
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+
+    // hack to override big ids from fetch middleware which are not supported in xrpl servers
+    // TODO: fix this for xrpl controllers.
+    request.id = baseControllers.randomId();
+    if (method !== RPC_METHODS.GET_ACCOUNTS) return next();
+    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+    // This calls from the prefs controller
+    const accounts = await getAccounts(request);
+    response.result = accounts;
+    return undefined;
+  });
+}
+function createGenericJRPCMiddleware(targetMethod, handler) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== targetMethod) return next();
+    if (!handler) throw new Error(`WalletMiddleware - ${targetMethod} not provided`);
+    const result = await handler(request);
+    response.result = result;
+    return undefined;
+  });
+}
+function createXRPLMiddleware(providerHandlers) {
+  const {
+    getAccounts,
+    submitTransaction,
+    signTransaction,
+    signMessage,
+    getKeyPair,
+    getPublicKey
+  } = providerHandlers;
+  return auth.mergeMiddleware([createGetAccountsMiddleware({
+    getAccounts
+  }), createGenericJRPCMiddleware(RPC_METHODS.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(RPC_METHODS.SUBMIT_TRANSACTION, submitTransaction), createGenericJRPCMiddleware(RPC_METHODS.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware(RPC_METHODS.GET_KEY_PAIR, getKeyPair), createGenericJRPCMiddleware(RPC_METHODS.GET_PUBLIC_KEY, getPublicKey)]);
+}
+function creatXrplChainSwitchMiddleware({
+  addChainConfig,
+  switchChain
+}) {
+  return auth.mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.ADD_CHAIN, addChainConfig), createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
+}
+
+exports.RPC_METHODS = RPC_METHODS;
+exports.creatXrplChainSwitchMiddleware = creatXrplChainSwitchMiddleware;
+exports.createGenericJRPCMiddleware = createGenericJRPCMiddleware;
+exports.createGetAccountsMiddleware = createGetAccountsMiddleware;
+exports.createXRPLMiddleware = createXRPLMiddleware;

package/dist/lib.cjs/react/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var useWeb3Auth = require('./no-modal/hooks/useWeb3Auth.js');
+var Web3AuthProvider = require('./no-modal/Web3AuthProvider.js');
+var useWalletServicesPlugin = require('./wallet-services-plugin/hooks/useWalletServicesPlugin.js');
+var WalletServicesContext = require('./wallet-services-plugin/WalletServicesContext.js');
+var WalletServicesProvider = require('./wallet-services-plugin/WalletServicesProvider.js');
+
+
+
+exports.useWeb3Auth = useWeb3Auth.useWeb3Auth;
+exports.Web3AuthProvider = Web3AuthProvider.Web3AuthProvider;
+exports.useWalletServicesPlugin = useWalletServicesPlugin.useWalletServicesPlugin;
+exports.WalletServicesContext = WalletServicesContext.WalletServicesContext;
+exports.WalletServicesContextProvider = WalletServicesContext.WalletServicesContextProvider;
+exports.WalletServicesProvider = WalletServicesProvider.WalletServicesProvider;

package/dist/lib.cjs/react/no-modal/Web3AuthInnerContext.js

@@ -0,0 +1,216 @@
+'use strict';
+
+var react = require('react');
+var index = require('../../base/errors/index.js');
+var noModal = require('../../noModal.js');
+var constants = require('../../base/adapter/constants.js');
+
+const Web3AuthInnerContext = react.createContext(null);
+function Web3AuthInnerProvider(params) {
+  const {
+    children,
+    config
+  } = params;
+  const [web3Auth, setWeb3Auth] = react.useState(null);
+  const [isConnecting, setIsConnecting] = react.useState(false);
+  const [isInitializing, setIsInitializing] = react.useState(false);
+  const [initError, setInitError] = react.useState(null);
+  const [connectError, setConnectError] = react.useState(null);
+  const [isConnected, setIsConnected] = react.useState(false);
+  const [provider, setProvider] = react.useState(null);
+  const [userInfo, setUserInfo] = react.useState(null);
+  const [isMFAEnabled, setIsMFAEnabled] = react.useState(false);
+  const [isInitialized, setIsInitialized] = react.useState(false);
+  const [status, setStatus] = react.useState(null);
+  const addPlugin = react.useCallback(plugin => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    return web3Auth.addPlugin(plugin);
+  }, [web3Auth]);
+  const getPlugin = react.useCallback(name => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    return web3Auth.getPlugin(name);
+  }, [web3Auth]);
+  react.useEffect(() => {
+    const resetHookState = () => {
+      setProvider(null);
+      setUserInfo(null);
+      setIsMFAEnabled(false);
+      setIsConnected(false);
+      setStatus(null);
+    };
+    resetHookState();
+    const {
+      web3AuthOptions,
+      adapters = [],
+      plugins = []
+    } = config;
+    const web3Instance = new noModal.Web3AuthNoModal(web3AuthOptions);
+    if (adapters.length) adapters.map(adapter => web3Instance.configureAdapter(adapter));
+    if (plugins.length) plugins.forEach(plugin => {
+      web3Instance.addPlugin(plugin);
+    });
+    setWeb3Auth(web3Instance);
+  }, [config]);
+  react.useEffect(() => {
+    async function init() {
+      try {
+        setInitError(null);
+        setIsInitializing(true);
+        await web3Auth.init();
+      } catch (error) {
+        setInitError(error);
+      } finally {
+        setIsInitializing(false);
+      }
+    }
+    if (web3Auth) init();
+  }, [web3Auth]);
+  react.useEffect(() => {
+    const addState = async () => {
+      setProvider(web3Auth.provider);
+      const userState = await web3Auth.getUserInfo();
+      setUserInfo(userState);
+      setIsMFAEnabled((userState === null || userState === void 0 ? void 0 : userState.isMfaEnabled) || false);
+    };
+    const resetState = () => {
+      setProvider(null);
+      setUserInfo(null);
+      setIsMFAEnabled(false);
+    };
+    if (web3Auth) {
+      if (isConnected) addState();else resetState();
+    }
+  }, [web3Auth, isConnected]);
+
+  // TODO: don't throw error in init, connect in v9
+
+  react.useEffect(() => {
+    const notReadyListener = () => setStatus(constants.ADAPTER_STATUS.NOT_READY);
+    const readyListener = () => {
+      setStatus(web3Auth.status);
+      setIsInitialized(true);
+    };
+    const connectedListener = () => {
+      setStatus(web3Auth.status);
+      // we do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
+      if (web3Auth.status === constants.ADAPTER_STATUS.CONNECTED) {
+        setIsInitialized(true);
+        setIsConnected(true);
+      }
+    };
+    const disconnectedListener = () => {
+      setStatus(web3Auth.status);
+      setIsConnected(false);
+    };
+    const connectingListener = () => {
+      setStatus(web3Auth.status);
+    };
+    const errorListener = () => {
+      setStatus(constants.ADAPTER_STATUS.ERRORED);
+    };
+    if (web3Auth) {
+      // web3Auth is initialized here.
+      setStatus(web3Auth.status);
+      web3Auth.on(constants.ADAPTER_EVENTS.NOT_READY, notReadyListener);
+      web3Auth.on(constants.ADAPTER_EVENTS.READY, readyListener);
+      web3Auth.on(constants.ADAPTER_EVENTS.CONNECTED, connectedListener);
+      web3Auth.on(constants.ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
+      web3Auth.on(constants.ADAPTER_EVENTS.CONNECTING, connectingListener);
+      web3Auth.on(constants.ADAPTER_EVENTS.ERRORED, errorListener);
+    }
+    return () => {
+      if (web3Auth) {
+        web3Auth.off(constants.ADAPTER_EVENTS.NOT_READY, notReadyListener);
+        web3Auth.off(constants.ADAPTER_EVENTS.READY, readyListener);
+        web3Auth.off(constants.ADAPTER_EVENTS.CONNECTED, connectedListener);
+        web3Auth.off(constants.ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
+        web3Auth.off(constants.ADAPTER_EVENTS.CONNECTING, connectingListener);
+        web3Auth.off(constants.ADAPTER_EVENTS.ERRORED, errorListener);
+      }
+    };
+  }, [web3Auth]);
+  const enableMFA = react.useCallback(async loginParams => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    if (!isConnected) throw index.WalletLoginError.notConnectedError();
+    await web3Auth.enableMFA(loginParams);
+    const localUserInfo = await web3Auth.getUserInfo();
+    setUserInfo(localUserInfo);
+    setIsMFAEnabled(localUserInfo.isMfaEnabled || false);
+  }, [web3Auth, isConnected]);
+  const manageMFA = react.useCallback(async loginParams => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    if (!isConnected) throw index.WalletLoginError.notConnectedError();
+    await web3Auth.manageMFA(loginParams);
+  }, [web3Auth, isConnected]);
+  const logout = react.useCallback(async (logoutParams = {
+    cleanup: false
+  }) => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    if (!isConnected) throw index.WalletLoginError.notConnectedError();
+    await web3Auth.logout(logoutParams);
+  }, [web3Auth, isConnected]);
+  const connectTo = react.useCallback(async (walletName, loginParams) => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    try {
+      setConnectError(null);
+      setIsConnecting(true);
+      const localProvider = await web3Auth.connectTo(walletName, loginParams);
+      return localProvider;
+    } catch (error) {
+      setConnectError(error);
+      throw error;
+    } finally {
+      setIsConnecting(false);
+    }
+  }, [web3Auth]);
+  const addAndSwitchChain = react.useCallback(async chainConfig => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    await web3Auth.addChain(chainConfig);
+    await web3Auth.switchChain({
+      chainId: chainConfig.chainId
+    });
+  }, [web3Auth]);
+  const authenticateUser = react.useCallback(async () => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    return web3Auth.authenticateUser();
+  }, [web3Auth]);
+  const addChain = react.useCallback(async chainConfig => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    return web3Auth.addChain(chainConfig);
+  }, [web3Auth]);
+  const switchChain = react.useCallback(chainParams => {
+    if (!web3Auth) throw index.WalletInitializationError.notReady();
+    return web3Auth.switchChain(chainParams);
+  }, [web3Auth]);
+  const value = react.useMemo(() => {
+    return {
+      web3Auth,
+      isConnected,
+      isInitialized,
+      provider,
+      userInfo,
+      isMFAEnabled,
+      status,
+      getPlugin,
+      connectTo,
+      enableMFA,
+      manageMFA,
+      logout,
+      addAndSwitchChain,
+      addChain,
+      addPlugin,
+      authenticateUser,
+      switchChain,
+      isInitializing,
+      isConnecting,
+      initError,
+      connectError
+    };
+  }, [web3Auth, isConnected, isInitialized, provider, userInfo, isMFAEnabled, status, connectTo, getPlugin, enableMFA, manageMFA, logout, addAndSwitchChain, addChain, addPlugin, authenticateUser, switchChain, isConnecting, isInitializing, initError, connectError]);
+  return react.createElement(Web3AuthInnerContext.Provider, {
+    value
+  }, children);
+}
+
+exports.Web3AuthInnerContext = Web3AuthInnerContext;
+exports.Web3AuthInnerProvider = Web3AuthInnerProvider;

package/dist/lib.cjs/react/no-modal/Web3AuthProvider.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var react = require('react');
+var Web3AuthInnerContext = require('./Web3AuthInnerContext.js');
+
+function Web3AuthProvider({
+  config,
+  children
+}) {
+  return react.createElement(Web3AuthInnerContext.Web3AuthInnerProvider, {
+    config
+  }, children);
+}
+
+exports.Web3AuthProvider = Web3AuthProvider;

package/dist/lib.cjs/react/no-modal/hooks/useWeb3Auth.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var react = require('react');
+var index = require('../../../base/errors/index.js');
+var Web3AuthInnerContext = require('../Web3AuthInnerContext.js');
+
+const useWeb3Auth = () => {
+  const context = react.useContext(Web3AuthInnerContext.Web3AuthInnerContext);
+  if (!context) {
+    throw index.WalletInitializationError.fromCode(1000, "usage of useWeb3Auth not wrapped in `Web3AuthContextProvider`.");
+  }
+  return context;
+};
+
+exports.useWeb3Auth = useWeb3Auth;

package/dist/lib.cjs/react/wallet-services-plugin/WalletServicesContext.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var react = require('react');
+var IPlugin = require('../../base/plugin/IPlugin.js');
+var errors = require('../../base/plugin/errors.js');
+
+const WalletServicesContext = react.createContext(null);
+function WalletServicesContextProvider({
+  children,
+  context
+}) {
+  const [isPluginConnected, setIsPluginConnected] = react.useState(false);
+  const [walletServicesPlugin, setWalletServicesPlugin] = react.useState(null);
+  const web3AuthContext = react.useContext(context);
+  const {
+    getPlugin,
+    isInitialized,
+    isConnected
+  } = web3AuthContext;
+  react.useEffect(() => {
+    if (isInitialized) {
+      const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
+      setWalletServicesPlugin(plugin);
+    }
+  }, [isInitialized, getPlugin]);
+  react.useEffect(() => {
+    if (isConnected) {
+      const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
+      if (!walletServicesPlugin) setWalletServicesPlugin(plugin);
+    }
+  }, [isConnected, getPlugin, walletServicesPlugin]);
+  react.useEffect(() => {
+    const connectedListener = () => {
+      setIsPluginConnected(true);
+    };
+    const disconnectedListener = () => {
+      setIsPluginConnected(false);
+    };
+    if (walletServicesPlugin) {
+      walletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
+      walletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+    }
+    return () => {
+      if (walletServicesPlugin) {
+        walletServicesPlugin.off(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
+        walletServicesPlugin.off(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      }
+    };
+  }, [walletServicesPlugin]);
+  const showWalletConnectScanner = react.useCallback(async showWalletConnectParams => {
+    if (!walletServicesPlugin) throw errors.WalletServicesPluginError.notInitialized();
+    if (!isPluginConnected) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+    return walletServicesPlugin.showWalletConnectScanner(showWalletConnectParams);
+  }, [walletServicesPlugin, isPluginConnected]);
+  const showWalletUI = react.useCallback(async showWalletUiParams => {
+    if (!walletServicesPlugin) throw errors.WalletServicesPluginError.notInitialized();
+    if (!isPluginConnected) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+    return walletServicesPlugin.showWalletUi(showWalletUiParams);
+  }, [walletServicesPlugin, isPluginConnected]);
+  const showCheckout = react.useCallback(async showCheckoutParams => {
+    if (!walletServicesPlugin) throw errors.WalletServicesPluginError.notInitialized();
+    if (!isPluginConnected) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+    return walletServicesPlugin.showCheckout(showCheckoutParams);
+  }, [walletServicesPlugin, isPluginConnected]);
+  const showSwap = react.useCallback(async showSwapParams => {
+    if (!walletServicesPlugin) throw errors.WalletServicesPluginError.notInitialized();
+    if (!isPluginConnected) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+    return walletServicesPlugin.showSwap(showSwapParams);
+  }, [walletServicesPlugin, isPluginConnected]);
+  const value = react.useMemo(() => {
+    return {
+      plugin: walletServicesPlugin,
+      isPluginConnected,
+      showWalletConnectScanner,
+      showCheckout,
+      showWalletUI,
+      showSwap
+    };
+  }, [walletServicesPlugin, isPluginConnected, showWalletConnectScanner, showCheckout, showWalletUI, showSwap]);
+  return react.createElement(WalletServicesContext.Provider, {
+    value
+  }, children);
+}
+
+exports.WalletServicesContext = WalletServicesContext;
+exports.WalletServicesContextProvider = WalletServicesContextProvider;

package/dist/lib.cjs/react/wallet-services-plugin/WalletServicesProvider.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var react = require('react');
+var WalletServicesContext = require('./WalletServicesContext.js');
+
+function WalletServicesProvider({
+  children,
+  context
+}) {
+  const wsElement = react.createElement(WalletServicesContext.WalletServicesContextProvider, {
+    context
+  }, children);
+  return wsElement;
+}
+
+exports.WalletServicesProvider = WalletServicesProvider;

package/dist/lib.cjs/react/wallet-services-plugin/hooks/useWalletServicesPlugin.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var react = require('react');
+var index = require('../../../base/errors/index.js');
+var WalletServicesContext = require('../WalletServicesContext.js');
+
+const useWalletServicesPlugin = () => {
+  const context = react.useContext(WalletServicesContext.WalletServicesContext);
+  if (!context) {
+    throw index.WalletInitializationError.fromCode(1000, "usage of useWalletServicesPlugin not wrapped in `WalletServicesContextProvider`.");
+  }
+  return context;
+};
+
+exports.useWalletServicesPlugin = useWalletServicesPlugin;

package/dist/lib.cjs/vue/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var useWeb3Auth = require('./no-modal/composables/useWeb3Auth.js');
+var Web3AuthProvider = require('./no-modal/Web3AuthProvider.js');
+var useWalletServicesPlugin = require('./wallet-services-plugin/composables/useWalletServicesPlugin.js');
+var context = require('./wallet-services-plugin/context.js');
+var WalletServicesProvider = require('./wallet-services-plugin/WalletServicesProvider.js');
+
+
+
+exports.useWeb3Auth = useWeb3Auth.useWeb3Auth;
+exports.Web3AuthProvider = Web3AuthProvider.Web3AuthProvider;
+exports.useWalletServicesPlugin = useWalletServicesPlugin.useWalletServicesPlugin;
+exports.WalletServicesContextKey = context.WalletServicesContextKey;
+exports.WalletServicesProvider = WalletServicesProvider.WalletServicesProvider;