@web3auth/no-modal 10.15.0 → 11.0.0-beta.0

package/dist/lib.esm/vue/solana/composables/useSignAndSendTransaction.js

@@ -1,6 +1,7 @@
 import { ref } from 'vue';
 import { WalletInitializationError } from '../../../base/errors/index.js';
 import { useSolanaWallet } from './useSolanaWallet.js';
+import { walletSignAndSendTransaction } from '../../../base/wallet/solana.js';
 import { log } from '../../../base/loglevel.js';
 
 const useSignAndSendTransaction = () => {
@@ -15,7 +16,7 @@ const useSignAndSendTransaction = () => {
     error.value = null;
     try {
       if (!solanaWallet.value) throw WalletInitializationError.notReady();
-      const signature = await solanaWallet.value.signAndSendTransaction(transaction);
+      const signature = await walletSignAndSendTransaction(solanaWallet.value, transaction);
       data.value = signature;
       return signature;
     } catch (err) {

package/dist/lib.esm/vue/solana/composables/useSignMessage.js

@@ -1,6 +1,7 @@
 import { ref } from 'vue';
 import { useSolanaWallet } from './useSolanaWallet.js';
 import { WalletInitializationError } from '../../../base/errors/index.js';
+import { walletSignMessage } from '../../../base/wallet/solana.js';
 import { log } from '../../../base/loglevel.js';
 
 const useSignMessage = () => {
@@ -17,7 +18,7 @@ const useSignMessage = () => {
     try {
       var _accounts$value;
       if (!solanaWallet.value) throw WalletInitializationError.notReady();
-      const signature = await solanaWallet.value.signMessage(message, from !== null && from !== void 0 ? from : (_accounts$value = accounts.value) === null || _accounts$value === void 0 ? void 0 : _accounts$value[0]);
+      const signature = await walletSignMessage(solanaWallet.value, message, from !== null && from !== void 0 ? from : (_accounts$value = accounts.value) === null || _accounts$value === void 0 ? void 0 : _accounts$value[0]);
       data.value = signature;
       return signature;
     } catch (err) {

package/dist/lib.esm/vue/solana/composables/useSignTransaction.js

@@ -1,6 +1,7 @@
 import { ref } from 'vue';
-import { WalletInitializationError } from '../../../base/errors/index.js';
 import { useSolanaWallet } from './useSolanaWallet.js';
+import { WalletInitializationError } from '../../../base/errors/index.js';
+import { walletSignTransaction } from '../../../base/wallet/solana.js';
 import { log } from '../../../base/loglevel.js';
 
 const useSignTransaction = () => {
@@ -15,7 +16,7 @@ const useSignTransaction = () => {
     error.value = null;
     try {
       if (!solanaWallet.value) throw WalletInitializationError.notReady();
-      const signedTransaction = await solanaWallet.value.signTransaction(transaction);
+      const signedTransaction = await walletSignTransaction(solanaWallet.value, transaction);
       data.value = signedTransaction;
       return signedTransaction;
     } catch (err) {

package/dist/lib.esm/vue/solana/composables/useSolanaClient.js

@@ -0,0 +1,12 @@
+import { inject, ref } from 'vue';
+import { SOLANA_CLIENT_KEY } from '../constants.js';
+
+/**
+ * Injects the Solana Framework Kit client when inside SolanaProvider and Web3Auth is connected on Solana.
+ * Otherwise returns null.
+ */
+function useSolanaClient() {
+  return inject(SOLANA_CLIENT_KEY, ref(null));
+}
+
+export { useSolanaClient };

package/dist/lib.esm/vue/solana/composables/useSolanaWallet.js

@@ -1,64 +1,82 @@
-import { Connection } from '@solana/web3.js';
-import { ref, shallowRef, computed, watch } from 'vue';
+import { createSolanaRpc } from '@solana/kit';
+import { StandardEvents } from '@wallet-standard/features';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { ref, shallowRef, onScopeDispose, watch } from 'vue';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { SolanaWallet } from '../../../providers/solana-provider/solanaWallet.js';
+import { WALLET_CONNECTORS } from '../../../base/wallet/index.js';
 import { useWeb3Auth } from '../../composables/useWeb3Auth.js';
 import { useChain } from '../../composables/useChain.js';
 
 const useSolanaWallet = () => {
   const {
-    provider,
+    connection,
     web3Auth
   } = useWeb3Auth();
   const {
     chainNamespace
   } = useChain();
-  const accounts = ref([]);
+  const accounts = ref(null);
   const solanaWallet = shallowRef(null);
-  const connection = shallowRef(null);
-  const isSolana = computed(() => chainNamespace.value === CHAIN_NAMESPACES.SOLANA);
-  const setupWallet = async () => {
-    var _web3Auth$value;
-    if (!isSolana.value) {
-      return;
-    }
-    if (!provider.value) {
-      return;
-    }
-    solanaWallet.value = new SolanaWallet(provider.value);
-    const result = await solanaWallet.value.getAccounts();
-    if ((result === null || result === void 0 ? void 0 : result.length) > 0) {
-      accounts.value = result;
-    }
-    if ((_web3Auth$value = web3Auth.value) !== null && _web3Auth$value !== void 0 && (_web3Auth$value = _web3Auth$value.currentChain) !== null && _web3Auth$value !== void 0 && _web3Auth$value.rpcTarget) {
-      connection.value = new Connection(web3Auth.value.currentChain.rpcTarget);
+  const rpc = shallowRef(null);
+  let unsubscribeStandardEvents = null;
+  const teardownWalletListeners = () => {
+    var _unsubscribeStandardE;
+    (_unsubscribeStandardE = unsubscribeStandardEvents) === null || _unsubscribeStandardE === void 0 || _unsubscribeStandardE();
+    unsubscribeStandardEvents = null;
+  };
+  const syncAccounts = () => {
+    var _solanaWallet$value$a, _solanaWallet$value;
+    const accts = (_solanaWallet$value$a = (_solanaWallet$value = solanaWallet.value) === null || _solanaWallet$value === void 0 ? void 0 : _solanaWallet$value.accounts.map(a => a.address)) !== null && _solanaWallet$value$a !== void 0 ? _solanaWallet$value$a : [];
+    accounts.value = accts.length > 0 ? accts : null;
+  };
+  const setupWallet = () => {
+    var _connection$value$sol, _connection$value, _web3Auth$value;
+    teardownWalletListeners();
+    const wallet = (_connection$value$sol = (_connection$value = connection.value) === null || _connection$value === void 0 ? void 0 : _connection$value.solanaWallet) !== null && _connection$value$sol !== void 0 ? _connection$value$sol : null;
+    if (!wallet) return;
+    solanaWallet.value = wallet;
+    syncAccounts();
+    unsubscribeStandardEvents = wallet.features[StandardEvents].on("change", syncAccounts);
+    if ((_web3Auth$value = web3Auth.value) !== null && _web3Auth$value !== void 0 && (_web3Auth$value = _web3Auth$value.currentChain) !== null && _web3Auth$value !== void 0 && _web3Auth$value.rpcTarget && chainNamespace.value === CHAIN_NAMESPACES.SOLANA) {
+      rpc.value = createSolanaRpc(web3Auth.value.currentChain.rpcTarget);
     }
   };
   const resetWallet = () => {
+    teardownWalletListeners();
     solanaWallet.value = null;
     accounts.value = null;
-    connection.value = null;
+    rpc.value = null;
   };
-  if (provider.value && !solanaWallet.value) {
-    setupWallet();
-  }
-  watch([provider, chainNamespace], async ([newProvider, newChainNamespace]) => {
-    if (!newProvider || newChainNamespace !== CHAIN_NAMESPACES.SOLANA) {
-      if (solanaWallet.value) {
-        resetWallet();
-      }
-      return;
+  onScopeDispose(teardownWalletListeners);
+  const getPrivateKey = async () => {
+    var _connection$value2, _web3Auth$value$conne;
+    if (!web3Auth.value) throw new Error("Web3Auth not initialized");
+    if (((_connection$value2 = connection.value) === null || _connection$value2 === void 0 ? void 0 : _connection$value2.connectorName) !== WALLET_CONNECTORS.AUTH) {
+      throw new Error("getPrivateKey is only supported with the Auth connector");
     }
-    if (newProvider && !solanaWallet.value) {
-      setupWallet();
+    const provider = (_web3Auth$value$conne = web3Auth.value.connectedConnector) === null || _web3Auth$value$conne === void 0 ? void 0 : _web3Auth$value$conne.provider;
+    if (!provider) throw new Error("Provider not available");
+    const privateKey = await provider.request({
+      method: SOLANA_METHOD_TYPES.SOLANA_PRIVATE_KEY
+    });
+    if (!privateKey) throw new Error("Failed to retrieve private key");
+    return privateKey;
+  };
+  watch([connection, chainNamespace], ([newConnection, newChainNamespace]) => {
+    if (!(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet)) {
+      if (solanaWallet.value) resetWallet();
+      return;
     }
+    // setup wallet if not setup or chain namespace is changed to solana
+    if (!solanaWallet.value || newChainNamespace === CHAIN_NAMESPACES.SOLANA) setupWallet();
   }, {
     immediate: true
   });
   return {
     solanaWallet,
     accounts,
-    connection
+    rpc,
+    getPrivateKey
   };
 };
 

package/dist/lib.esm/vue/solana/constants.js

@@ -0,0 +1,3 @@
+const SOLANA_CLIENT_KEY = Symbol("SolanaClient");
+
+export { SOLANA_CLIENT_KEY };

package/dist/lib.esm/vue/solana/index.js

@@ -1,4 +1,7 @@
+export { SOLANA_CLIENT_KEY } from './constants.js';
+export { SolanaProvider } from './provider.js';
 export { useSignAndSendTransaction } from './composables/useSignAndSendTransaction.js';
 export { useSignMessage } from './composables/useSignMessage.js';
 export { useSignTransaction } from './composables/useSignTransaction.js';
+export { useSolanaClient } from './composables/useSolanaClient.js';
 export { useSolanaWallet } from './composables/useSolanaWallet.js';

package/dist/lib.esm/vue/solana/provider.js

@@ -0,0 +1,95 @@
+import { createWalletStandardConnector, createClient } from '@solana/client';
+import { defineComponent, ref, provide, watch, h, Fragment } from 'vue';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { SOLANA_CLIENT_KEY } from './constants.js';
+import { useWeb3Auth } from '../composables/useWeb3Auth.js';
+import { log } from '../../base/loglevel.js';
+
+const disposeClient = async client => {
+  try {
+    await client.actions.disconnectWallet();
+  } catch (e) {
+    log.warn("Solana client disconnect", e);
+  }
+  client.destroy();
+};
+
+/**
+ * Syncs Web3Auth Solana connection with Framework Kit client.
+ * When user is connected via Web3Auth and current chain is Solana, creates a Framework Kit client
+ * with Web3Auth as the wallet connector and connects it (same pattern as Wagmi provider).
+ */
+const SolanaProvider = defineComponent({
+  name: "SolanaProvider",
+  setup(_, {
+    slots
+  }) {
+    const {
+      isConnected,
+      connection,
+      web3Auth
+    } = useWeb3Auth();
+    const clientRef = ref(null);
+
+    // provide the client to the app
+    provide(SOLANA_CLIENT_KEY, clientRef);
+
+    // watch for changes in the connection and chain namespace
+    watch([isConnected, connection], async ([newIsConnected, newConnection]) => {
+      if (!newIsConnected || !(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet)) {
+        if (clientRef.value) {
+          await disposeClient(clientRef.value);
+          clientRef.value = null;
+        }
+        return;
+      }
+      const currentChain = web3Auth.value.currentChain;
+      let chainConfig;
+      if ((currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) === CHAIN_NAMESPACES.SOLANA) {
+        chainConfig = currentChain;
+      } else {
+        // use the 1st Solana chain if current chain is not solana
+        chainConfig = web3Auth.value.coreOptions.chains.find(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
+        if (!chainConfig) return;
+      }
+      const prevClient = clientRef.value;
+      try {
+        // create a wallet standard connector from connected wallet
+        const solanaWalletId = "wallet-standard:" + connection.value.connectorName;
+        const connector = createWalletStandardConnector(connection.value.solanaWallet, {
+          id: solanaWalletId,
+          name: connection.value.connectorName
+        });
+
+        // create a solana client
+        const {
+          rpcTarget,
+          wsTarget
+        } = chainConfig;
+        const client = createClient({
+          endpoint: rpcTarget,
+          websocketEndpoint: wsTarget,
+          walletConnectors: [connector]
+        });
+        clientRef.value = client;
+        if (prevClient) await disposeClient(prevClient);
+
+        // connect the client to the wallet
+        await client.actions.connectWallet(solanaWalletId, {
+          autoConnect: true
+        });
+      } catch (err) {
+        log.error("Failed to create or connect Solana client", err);
+        clientRef.value = null;
+      }
+    }, {
+      immediate: true
+    });
+    return () => {
+      var _slots$default, _slots$default2;
+      return h(Fragment, null, (_slots$default = (_slots$default2 = slots.default) === null || _slots$default2 === void 0 ? void 0 : _slots$default2.call(slots)) !== null && _slots$default !== void 0 ? _slots$default : []);
+    };
+  }
+});
+
+export { SolanaProvider };

package/dist/lib.esm/vue/useWalletServicesInnerContextValue.js

@@ -0,0 +1,58 @@
+import { shallowRef, ref, watch } from 'vue';
+import { EVM_PLUGINS, PLUGIN_EVENTS } from '../base/plugin/IPlugin.js';
+import { CONNECTED_STATUSES } from '../base/connector/connectorStatus.js';
+
+function useWalletServicesInnerContextValue(web3AuthContext) {
+  const {
+    getPlugin,
+    isInitialized,
+    isConnected
+  } = web3AuthContext;
+  const walletServicesPlugin = shallowRef(null);
+  const ready = ref(false);
+  const connecting = ref(false);
+  watch(isInitialized, newIsInitialized => {
+    if (newIsInitialized) {
+      const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
+      walletServicesPlugin.value = plugin;
+    }
+  });
+  watch(isConnected, newIsConnected => {
+    if (newIsConnected) {
+      const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
+      walletServicesPlugin.value = plugin;
+      // When rehydrating, the connected listener may be registered after the connected event is emitted.
+      if (CONNECTED_STATUSES.includes(plugin === null || plugin === void 0 ? void 0 : plugin.status)) ready.value = true;
+    }
+  });
+  watch(walletServicesPlugin, (newWalletServicesPlugin, prevWalletServicesPlugin) => {
+    const connectedListener = () => {
+      ready.value = true;
+    };
+    const disconnectedListener = () => {
+      ready.value = false;
+    };
+    const connectingListener = () => {
+      connecting.value = true;
+    };
+    const previousPlugin = prevWalletServicesPlugin;
+    const currentPlugin = newWalletServicesPlugin;
+    if (previousPlugin && currentPlugin !== previousPlugin) {
+      previousPlugin.removeListener(PLUGIN_EVENTS.CONNECTED, connectedListener);
+      previousPlugin.removeListener(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      previousPlugin.removeListener(PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+    if (currentPlugin && currentPlugin !== previousPlugin) {
+      currentPlugin.on(PLUGIN_EVENTS.CONNECTED, connectedListener);
+      currentPlugin.on(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      currentPlugin.on(PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+  });
+  return {
+    plugin: walletServicesPlugin,
+    ready,
+    connecting
+  };
+}
+
+export { useWalletServicesInnerContextValue };

package/dist/lib.esm/vue/useWeb3AuthInnerContextValue.js

@@ -0,0 +1,204 @@
+import { shallowRef, ref, watch } from 'vue';
+import { ANALYTICS_INTEGRATION_TYPE } from '../base/analytics.js';
+import { log } from '../base/loglevel.js';
+import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../base/connector/constants.js';
+import { LOGIN_MODE } from '../base/constants.js';
+import { WalletInitializationError } from '../base/errors/index.js';
+
+function useWeb3AuthInnerContextValue({
+  Web3AuthConstructor,
+  watchSource,
+  getWeb3AuthOptions,
+  initialState,
+  createConnectionRef = () => ref(null)
+}) {
+  const web3Auth = shallowRef(null);
+  const connection = createConnectionRef();
+  const isMFAEnabled = ref(false);
+  const status = ref(null);
+  const chainId = ref(null);
+  const chainNamespace = ref(null);
+  const isInitializing = ref(false);
+  const initError = ref(null);
+  const isInitialized = ref(false);
+  const isConnected = ref(false);
+  const isAuthorized = ref(false);
+  const getPlugin = name => {
+    if (!web3Auth.value) throw WalletInitializationError.notReady();
+    return web3Auth.value.getPlugin(name);
+  };
+  const setIsMFAEnabled = isMfaEnabled => {
+    isMFAEnabled.value = isMfaEnabled;
+  };
+  watch(watchSource, (newSource, _, onInvalidate) => {
+    const resetHookState = () => {
+      connection.value = null;
+      isMFAEnabled.value = false;
+      isConnected.value = false;
+      isAuthorized.value = false;
+      status.value = null;
+      chainId.value = null;
+      chainNamespace.value = null;
+    };
+    onInvalidate(() => {
+      if (web3Auth.value) {
+        web3Auth.value.cleanup();
+      }
+    });
+    resetHookState();
+    const web3AuthInstance = new Web3AuthConstructor(getWeb3AuthOptions(newSource), initialState);
+    web3AuthInstance.setAnalyticsProperties({
+      integration_type: ANALYTICS_INTEGRATION_TYPE.VUE_COMPOSABLES
+    });
+    web3Auth.value = web3AuthInstance;
+  }, {
+    immediate: true
+  });
+  watch(web3Auth, async (newWeb3Auth, _, onInvalidate) => {
+    const controller = new AbortController();
+    onInvalidate(() => {
+      controller.abort();
+    });
+    if (newWeb3Auth) {
+      try {
+        initError.value = null;
+        isInitializing.value = true;
+        await newWeb3Auth.init({
+          signal: controller.signal
+        });
+      } catch (error) {
+        log.error("Error initializing web3auth", error);
+        initError.value = error;
+      } finally {
+        isInitializing.value = false;
+      }
+    }
+  }, {
+    immediate: true
+  });
+  watch(web3Auth, (newWeb3Auth, prevWeb3Auth) => {
+    const notReadyListener = () => {
+      status.value = web3Auth.value.status;
+    };
+    const readyListener = () => {
+      status.value = web3Auth.value.status;
+      isInitialized.value = true;
+    };
+    const connectedListener = data => {
+      if (data.pendingUserConsent) return;
+      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 === CONNECTOR_STATUS.CONNECTED) {
+        var _currentChain$chainNa, _currentChain;
+        if (!isInitialized.value) isInitialized.value = true;
+        isConnected.value = true;
+        connection.value = newWeb3Auth.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_currentChain$chainNa = (_currentChain = web3Auth.value.currentChain) === null || _currentChain === void 0 ? void 0 : _currentChain.chainNamespace) !== null && _currentChain$chainNa !== void 0 ? _currentChain$chainNa : null;
+      }
+    };
+    const authorizedListener = () => {
+      status.value = web3Auth.value.status;
+      if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+        isAuthorized.value = true;
+        isConnected.value = true;
+      }
+    };
+    const consentAcceptedListener = () => {
+      status.value = web3Auth.value.status;
+      if (web3Auth.value.status === CONNECTOR_STATUS.CONNECTED || web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+        var _currentChain$chainNa2, _currentChain2;
+        if (!isInitialized.value) isInitialized.value = true;
+        isConnected.value = true;
+        connection.value = newWeb3Auth.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_currentChain$chainNa2 = (_currentChain2 = web3Auth.value.currentChain) === null || _currentChain2 === void 0 ? void 0 : _currentChain2.chainNamespace) !== null && _currentChain$chainNa2 !== void 0 ? _currentChain$chainNa2 : null;
+        if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+          isAuthorized.value = true;
+        }
+      }
+    };
+    const disconnectedListener = () => {
+      status.value = web3Auth.value.status;
+      isConnected.value = false;
+      connection.value = null;
+      isMFAEnabled.value = false;
+      isAuthorized.value = false;
+    };
+    const connectingListener = () => {
+      status.value = web3Auth.value.status;
+    };
+    const errorListener = () => {
+      status.value = web3Auth.value.status;
+    };
+    const mfaEnabledListener = () => {
+      isMFAEnabled.value = true;
+    };
+    if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.READY, readyListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.ERRORED, errorListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      if (prevWeb3Auth.loginMode === LOGIN_MODE.MODAL) {
+        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+    if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+      status.value = newWeb3Auth.status;
+      newWeb3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      if (newWeb3Auth.loginMode === LOGIN_MODE.MODAL) {
+        newWeb3Auth.on(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+  }, {
+    immediate: true
+  });
+  watch(connection, (newConnection, prevConnection) => {
+    var _prevConnection$ether, _newConnection$ethere;
+    const handleChainChange = newChainId => {
+      var _web3Auth$value$curre, _web3Auth$value;
+      chainId.value = newChainId;
+      chainNamespace.value = (_web3Auth$value$curre = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 || (_web3Auth$value = _web3Auth$value.currentChain) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.chainNamespace) !== null && _web3Auth$value$curre !== void 0 ? _web3Auth$value$curre : null;
+    };
+    const prevProvider = (_prevConnection$ether = prevConnection === null || prevConnection === void 0 ? void 0 : prevConnection.ethereumProvider) !== null && _prevConnection$ether !== void 0 ? _prevConnection$ether : null;
+    const newProvider = (_newConnection$ethere = newConnection === null || newConnection === void 0 ? void 0 : newConnection.ethereumProvider) !== null && _newConnection$ethere !== void 0 ? _newConnection$ethere : null;
+    if (prevProvider && newProvider !== prevProvider) {
+      prevProvider.removeListener("chainChanged", handleChainChange);
+    }
+    if (newProvider && newProvider !== prevProvider) {
+      newProvider.on("chainChanged", handleChainChange);
+    }
+  }, {
+    immediate: true
+  });
+  return {
+    web3Auth,
+    isConnected,
+    isAuthorized,
+    connection,
+    isInitializing,
+    initError,
+    isInitialized,
+    status,
+    isMFAEnabled,
+    chainId,
+    chainNamespace,
+    getPlugin,
+    setIsMFAEnabled
+  };
+}
+
+export { useWeb3AuthInnerContextValue };

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

@@ -1,6 +1,6 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { hydrate } from '@wagmi/core';
-import { configKey, createConfig, useConfig, useReconnect, useAccountEffect } from '@wagmi/vue';
+import { configKey, createConfig, useConfig, useReconnect, useConnectionEffect } from '@wagmi/vue';
 import { injected } from '@wagmi/vue/connectors';
 import { randomId } from '@web3auth/auth';
 import { defineChain, webSocket, http, fallback } from 'viem';
@@ -78,16 +78,16 @@ const Web3AuthWagmiProvider = defineComponent({
   setup() {
     const {
       isConnected,
-      provider
+      connection
     } = useWeb3Auth();
     const {
       disconnect
     } = useWeb3AuthDisconnect();
     const wagmiConfig = useConfig();
     const {
-      reconnect
+      mutate: reconnect
     } = useReconnect();
-    useAccountEffect({
+    useConnectionEffect({
       onDisconnect: async () => {
         log.info("Disconnected from wagmi");
         if (isConnected.value) await disconnect();
@@ -99,9 +99,11 @@ const Web3AuthWagmiProvider = defineComponent({
         }
       }
     });
-    watch(isConnected, async newIsConnected => {
-      if (newIsConnected && provider.value) {
-        const connector = await setupConnector(provider.value, wagmiConfig);
+    watch([isConnected, connection], async () => {
+      var _connection$value;
+      const newIsConnected = isConnected.value;
+      if (newIsConnected && (_connection$value = connection.value) !== null && _connection$value !== void 0 && _connection$value.ethereumProvider) {
+        const connector = await setupConnector(connection.value.ethereumProvider, wagmiConfig);
         if (!connector) {
           throw new Error("Failed to setup connector");
         }