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

package/dist/lib.cjs/types/vue/solana/index.d.ts

@@ -0,0 +1 @@
+export * from "./composables";

package/dist/lib.cjs/types/vue/wagmi/constants.d.ts

@@ -0,0 +1,43 @@
+export declare const defaultWagmiConfig: import("wagmi").Config<readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    contracts: {
+        readonly ensRegistry: {
+            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+            readonly blockCreated: 19258213;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://eth.merkle.io"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+}], {
+    1: import("viem").HttpTransport<undefined, false>;
+}, readonly []>;

package/dist/lib.cjs/types/vue/wagmi/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./interface";
+export * from "./provider";

package/dist/lib.cjs/types/vue/wagmi/interface.d.ts

@@ -0,0 +1,4 @@
+import type { CreateConfigParameters, WagmiPluginOptions } from "@wagmi/vue";
+export type WagmiProviderProps = Omit<WagmiPluginOptions, "config"> & {
+    config?: Omit<CreateConfigParameters, "chains" | "connectors" | "transports" | "multiInjectedProviderDiscovery" | "client">;
+};

package/dist/lib.cjs/types/vue/wagmi/provider.d.ts

@@ -0,0 +1,17 @@
+import { type Config } from "@wagmi/core";
+import { PropType } from "vue";
+import { WagmiProviderProps } from "./interface";
+export declare const WagmiProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<WagmiProviderProps>;
+        required: false;
+    };
+}>, {
+    finalConfig: import("vue").ShallowRef<Config, Config>;
+    configKey: import("vue").Ref<string, string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<WagmiProviderProps>;
+        required: false;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/lib.cjs/vue/{wallet-services-plugin/WalletServicesProvider.js → WalletServicesInnerProvider.js}

@@ -2,32 +2,33 @@
 
 var vue = require('vue');
 require('@toruslabs/base-controllers');
-var index = require('../../base/composables/index.js');
 require('@babel/runtime/helpers/defineProperty');
 require('@web3auth/auth');
-require('../../base/errors/index.js');
-require('../../base/wallet/index.js');
-var constants = require('../../base/connector/constants.js');
+require('../base/errors/index.js');
+require('../base/wallet/index.js');
+var constants = require('../base/connector/constants.js');
 require('jwt-decode');
-require('../../base/loglevel.js');
-var errors = require('../../base/plugin/errors.js');
-var IPlugin = require('../../base/plugin/IPlugin.js');
+require('../base/loglevel.js');
+var errors = require('../base/plugin/errors.js');
+var IPlugin = require('../base/plugin/IPlugin.js');
 require('@toruslabs/constants');
 require('@toruslabs/http-helpers');
-var context = require('./context.js');
+var useWeb3AuthInner = require('./composables/useWeb3AuthInner.js');
+var WalletServicesContext = require('./context/WalletServicesContext.js');
 
-const WalletServicesProvider = vue.defineComponent({
-  name: "WalletServicesProvider",
+const WalletServicesInnerProvider = vue.defineComponent({
+  name: "WalletServicesInnerProvider",
   setup() {
-    const web3AuthContext = vue.inject(index.Web3AuthContextKey);
+    const web3AuthContext = useWeb3AuthInner.useWeb3AuthInner();
     if (!web3AuthContext) throw errors.WalletServicesPluginError.fromCode(1000, "`WalletServicesProvider` must be wrapped by `Web3AuthProvider`");
     const {
       getPlugin,
       isInitialized,
       isConnected
     } = web3AuthContext;
-    const walletServicesPlugin = vue.ref(null);
-    const isPluginConnected = vue.ref(false);
+    const walletServicesPlugin = vue.shallowRef(null);
+    const ready = vue.ref(false);
+    const connecting = vue.ref(false);
     vue.watch(isInitialized, newIsInitialized => {
       if (newIsInitialized) {
         const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
@@ -40,53 +41,35 @@ const WalletServicesProvider = vue.defineComponent({
         const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
         if (!walletServicesPlugin.value) walletServicesPlugin.value = plugin;
         // when rehydrating, the connectedListener may be registered after the connected event is emitted, we need to check the status here
-        if (((_walletServicesPlugin = walletServicesPlugin.value) === null || _walletServicesPlugin === void 0 ? void 0 : _walletServicesPlugin.status) === constants.CONNECTOR_STATUS.CONNECTED) isPluginConnected.value = true;
+        if (((_walletServicesPlugin = walletServicesPlugin.value) === null || _walletServicesPlugin === void 0 ? void 0 : _walletServicesPlugin.status) === constants.CONNECTOR_STATUS.CONNECTED) ready.value = true;
       }
     });
     vue.watch(walletServicesPlugin, (newWalletServicesPlugin, prevWalletServicesPlugin) => {
       const connectedListener = () => {
-        isPluginConnected.value = true;
+        ready.value = true;
       };
       const disconnectedListener = () => {
-        isPluginConnected.value = false;
+        ready.value = false;
+      };
+      const connectingListener = () => {
+        connecting.value = true;
       };
       // unregister previous listeners
       if (prevWalletServicesPlugin && newWalletServicesPlugin !== prevWalletServicesPlugin) {
         prevWalletServicesPlugin.off(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
         prevWalletServicesPlugin.off(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+        prevWalletServicesPlugin.off(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
       }
       if (newWalletServicesPlugin && newWalletServicesPlugin !== prevWalletServicesPlugin) {
         newWalletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
         newWalletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+        newWalletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
       }
     });
-    const showWalletConnectScanner = async showWalletConnectScannerParams => {
-      if (!walletServicesPlugin.value) throw errors.WalletServicesPluginError.notInitialized();
-      if (!isPluginConnected.value) throw errors.WalletServicesPluginError.walletPluginNotConnected();
-      return walletServicesPlugin.value.showWalletConnectScanner(showWalletConnectScannerParams);
-    };
-    const showWalletUI = async showWalletUiParams => {
-      if (!walletServicesPlugin.value) throw errors.WalletServicesPluginError.notInitialized();
-      if (!isPluginConnected.value) throw errors.WalletServicesPluginError.walletPluginNotConnected();
-      return walletServicesPlugin.value.showWalletUi(showWalletUiParams);
-    };
-    const showCheckout = async showCheckoutParams => {
-      if (!walletServicesPlugin.value) throw errors.WalletServicesPluginError.notInitialized();
-      if (!isPluginConnected.value) throw errors.WalletServicesPluginError.walletPluginNotConnected();
-      return walletServicesPlugin.value.showCheckout(showCheckoutParams);
-    };
-    const showSwap = async showSwapParams => {
-      if (!walletServicesPlugin.value) throw errors.WalletServicesPluginError.notInitialized();
-      if (!isPluginConnected.value) throw errors.WalletServicesPluginError.walletPluginNotConnected();
-      return walletServicesPlugin.value.showSwap(showSwapParams);
-    };
-    vue.provide(context.WalletServicesContextKey, {
+    vue.provide(WalletServicesContext.WalletServicesContextKey, {
       plugin: walletServicesPlugin,
-      isPluginConnected,
-      showWalletConnectScanner,
-      showCheckout,
-      showWalletUI,
-      showSwap
+      ready,
+      connecting
     });
   },
   render() {
@@ -95,4 +78,4 @@ const WalletServicesProvider = vue.defineComponent({
   }
 });
 
-exports.WalletServicesProvider = WalletServicesProvider;
+exports.WalletServicesInnerProvider = WalletServicesInnerProvider;

package/dist/lib.cjs/vue/{no-modal/Web3AuthProvider.js → Web3AuthProvider.js}

@@ -2,19 +2,20 @@
 
 var vue = require('vue');
 require('@toruslabs/base-controllers');
-var index = require('../../base/composables/index.js');
+var index = require('../base/composables/index.js');
 require('@babel/runtime/helpers/defineProperty');
 require('@web3auth/auth');
-var index$1 = require('../../base/errors/index.js');
-require('../../base/wallet/index.js');
-var constants = require('../../base/connector/constants.js');
+var index$1 = require('../base/errors/index.js');
+require('../base/wallet/index.js');
+var constants = require('../base/connector/constants.js');
 require('jwt-decode');
-require('../../base/loglevel.js');
-require('../../base/plugin/errors.js');
-require('../../base/plugin/IPlugin.js');
+require('../base/loglevel.js');
+require('../base/plugin/errors.js');
+require('../base/plugin/IPlugin.js');
 require('@toruslabs/constants');
 require('@toruslabs/http-helpers');
-var noModal = require('../../noModal.js');
+var noModal = require('../noModal.js');
+var WalletServicesInnerProvider = require('./WalletServicesInnerProvider.js');
 
 const Web3AuthProvider = vue.defineComponent({
   name: "Web3AuthProvider",
@@ -27,68 +28,31 @@ const Web3AuthProvider = vue.defineComponent({
   setup(props) {
     const web3Auth = vue.shallowRef(null);
     const provider = vue.ref(null);
-    const userInfo = vue.ref(null);
     const isMFAEnabled = vue.ref(false);
     const status = vue.ref(null);
     const isInitializing = vue.ref(false);
     const initError = vue.ref(null);
     const isInitialized = vue.ref(false);
-    const isConnecting = vue.ref(false);
-    const connectError = vue.ref(null);
     const isConnected = vue.ref(false);
     const getPlugin = name => {
       if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
       return web3Auth.value.getPlugin(name);
     };
-    const enableMFA = async loginParams => {
-      if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
-      if (!isConnected.value) throw index$1.WalletLoginError.notConnectedError();
-      await web3Auth.value.enableMFA(loginParams);
-      const localUserInfo = await web3Auth.value.getUserInfo();
-      userInfo.value = localUserInfo;
-      isMFAEnabled.value = localUserInfo.isMfaEnabled || false;
-    };
-    const manageMFA = async loginParams => {
-      if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
-      if (!isConnected.value) throw index$1.WalletLoginError.notConnectedError();
-      await web3Auth.value.manageMFA(loginParams);
+    const setIsMFAEnabled = isMfaEnabled => {
+      isMFAEnabled.value = isMfaEnabled;
     };
-    const logout = async (logoutParams = {
-      cleanup: false
-    }) => {
-      if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
-      if (!isConnected.value) throw index$1.WalletLoginError.notConnectedError();
-      await web3Auth.value.logout(logoutParams);
-    };
-    const connectTo = async (walletName, loginParams) => {
-      if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
-      try {
-        connectError.value = null;
-        isConnecting.value = true;
-        const localProvider = await web3Auth.value.connectTo(walletName, loginParams);
-        return localProvider;
-      } catch (error) {
-        connectError.value = error;
-      } finally {
-        isConnecting.value = false;
-      }
-    };
-    const authenticateUser = async () => {
-      if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
-      return web3Auth.value.authenticateUser();
-    };
-    const switchChain = chainParams => {
-      if (!web3Auth.value) throw index$1.WalletInitializationError.notReady();
-      return web3Auth.value.switchChain(chainParams);
-    };
-    vue.watch(() => props.config, newConfig => {
+    vue.watch(() => props.config, (newConfig, _, onInvalidate) => {
       const resetHookState = () => {
         provider.value = null;
-        userInfo.value = null;
         isMFAEnabled.value = false;
         isConnected.value = false;
         status.value = null;
       };
+      onInvalidate(() => {
+        if (web3Auth.value) {
+          web3Auth.value.cleanup();
+        }
+      });
       resetHookState();
       const {
         web3AuthOptions
@@ -98,12 +62,19 @@ const Web3AuthProvider = vue.defineComponent({
     }, {
       immediate: true
     });
-    vue.watch(web3Auth, async newWeb3Auth => {
+    vue.watch(web3Auth, async (newWeb3Auth, _, onInvalidate) => {
+      const controller = new AbortController();
+      // Invalidate the controller here before calling any async methods.
+      onInvalidate(() => {
+        controller.abort();
+      });
       if (newWeb3Auth) {
         try {
           initError.value = null;
           isInitializing.value = true;
-          await newWeb3Auth.init();
+          await newWeb3Auth.init({
+            signal: controller.signal
+          });
         } catch (error) {
           initError.value = error;
         } finally {
@@ -113,24 +84,10 @@ const Web3AuthProvider = vue.defineComponent({
     }, {
       immediate: true
     });
-    vue.watch(isConnected, () => {
-      if (web3Auth.value) {
-        const addState = async web3AuthInstance => {
-          provider.value = web3AuthInstance.provider;
-          const userState = await web3AuthInstance.getUserInfo();
-          userInfo.value = userState;
-          isMFAEnabled.value = (userState === null || userState === void 0 ? void 0 : userState.isMfaEnabled) || false;
-        };
-        const resetState = () => {
-          provider.value = null;
-          userInfo.value = null;
-          isMFAEnabled.value = false;
-        };
-        if (isConnected.value) addState(web3Auth.value);else resetState();
-      }
-    });
     vue.watch(web3Auth, (newWeb3Auth, prevWeb3Auth) => {
-      const notReadyListener = () => status.value = web3Auth.value.status;
+      const notReadyListener = () => {
+        status.value = web3Auth.value.status;
+      };
       const readyListener = () => {
         status.value = web3Auth.value.status;
         isInitialized.value = true;
@@ -139,19 +96,25 @@ const Web3AuthProvider = vue.defineComponent({
         status.value = web3Auth.value.status;
         // we do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
         if (web3Auth.value.status === constants.CONNECTOR_STATUS.CONNECTED) {
-          isInitialized.value = true;
+          if (!isInitialized.value) isInitialized.value = true;
           isConnected.value = true;
+          provider.value = newWeb3Auth.provider;
         }
       };
       const disconnectedListener = () => {
         status.value = web3Auth.value.status;
         isConnected.value = false;
+        provider.value = null;
+        isMFAEnabled.value = false;
       };
       const connectingListener = () => {
         status.value = web3Auth.value.status;
       };
       const errorListener = () => {
-        status.value = constants.CONNECTOR_EVENTS.ERRORED;
+        status.value = web3Auth.value.status;
+      };
+      const mfaEnabledListener = () => {
+        isMFAEnabled.value = true;
       };
       // unregister previous listeners
       if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
@@ -161,6 +124,8 @@ const Web3AuthProvider = vue.defineComponent({
         prevWeb3Auth.off(constants.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
         prevWeb3Auth.off(constants.CONNECTOR_EVENTS.CONNECTING, connectingListener);
         prevWeb3Auth.off(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
+        prevWeb3Auth.off(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+        prevWeb3Auth.off(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       }
       if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
         status.value = newWeb3Auth.status;
@@ -171,6 +136,8 @@ const Web3AuthProvider = vue.defineComponent({
         newWeb3Auth.on(constants.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
         newWeb3Auth.on(constants.CONNECTOR_EVENTS.CONNECTING, connectingListener);
         newWeb3Auth.on(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
+        newWeb3Auth.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+        newWeb3Auth.on(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       }
     }, {
       immediate: true
@@ -180,25 +147,17 @@ const Web3AuthProvider = vue.defineComponent({
       isConnected,
       isInitialized,
       provider,
-      userInfo,
-      isMFAEnabled,
       status,
-      getPlugin,
-      connectTo,
-      enableMFA,
-      manageMFA,
-      logout,
-      authenticateUser,
-      switchChain,
       isInitializing,
-      isConnecting,
       initError,
-      connectError
+      isMFAEnabled,
+      getPlugin,
+      setIsMFAEnabled
     });
   },
   render() {
     var _this$$slots$default;
-    return vue.h((_this$$slots$default = this.$slots.default) !== null && _this$$slots$default !== void 0 ? _this$$slots$default : "");
+    return vue.h(WalletServicesInnerProvider.WalletServicesInnerProvider, {}, (_this$$slots$default = this.$slots.default) !== null && _this$$slots$default !== void 0 ? _this$$slots$default : "");
   }
 });
 

package/dist/lib.cjs/vue/composables/useCheckout.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var vue = require('vue');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+var errors = require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var useWalletServicesPlugin = require('./useWalletServicesPlugin.js');
+
+const useCheckout = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin.useWalletServicesPlugin();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const showCheckout = async showCheckoutParams => {
+    loading.value = true;
+    error.value = null;
+    try {
+      if (!plugin) throw errors.WalletServicesPluginError.notInitialized();
+      if (!ready) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.value.showCheckout(showCheckoutParams);
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    showCheckout
+  };
+};
+
+exports.useCheckout = useCheckout;

package/dist/lib.cjs/vue/composables/useEnableMFA.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var vue = require('vue');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+var index = require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useEnableMFA = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const enableMFA = async () => {
+    try {
+      if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+      error.value = null;
+      loading.value = true;
+      await web3Auth.value.enableMFA();
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    enableMFA
+  };
+};
+
+exports.useEnableMFA = useEnableMFA;

package/dist/lib.cjs/vue/composables/useIdentityToken.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var vue = require('vue');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+var index = require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useIdentityToken = () => {
+  const {
+    web3Auth,
+    isConnected
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const token = vue.ref(null);
+  const authenticateUser = async () => {
+    try {
+      if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+      error.value = null;
+      loading.value = true;
+      const result = await web3Auth.value.authenticateUser();
+      if (result !== null && result !== void 0 && result.idToken) {
+        token.value = result.idToken;
+      }
+      return result === null || result === void 0 ? void 0 : result.idToken;
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  vue.watch(isConnected, newIsConnected => {
+    if (!newIsConnected && token.value) {
+      token.value = null;
+    }
+  });
+  return {
+    loading,
+    error,
+    token,
+    authenticateUser
+  };
+};
+
+exports.useIdentityToken = useIdentityToken;

package/dist/lib.cjs/vue/composables/useManageMFA.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var vue = require('vue');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+var index = require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useManageMFA = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const manageMFA = async () => {
+    try {
+      if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+      error.value = null;
+      loading.value = true;
+      await web3Auth.value.enableMFA();
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    manageMFA
+  };
+};
+
+exports.useManageMFA = useManageMFA;

package/dist/lib.cjs/vue/composables/useSwap.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var vue = require('vue');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/loglevel.js');
+var errors = require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var useWalletServicesPlugin = require('./useWalletServicesPlugin.js');
+
+const useSwap = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin.useWalletServicesPlugin();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const showSwap = async showSwapParams => {
+    loading.value = true;
+    error.value = null;
+    try {
+      if (!plugin) throw errors.WalletServicesPluginError.notInitialized();
+      if (!ready) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.value.showSwap(showSwapParams);
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    showSwap
+  };
+};
+
+exports.useSwap = useSwap;