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

package/dist/lib.cjs/types/providers/base-provider/baseProvider.d.ts

@@ -14,6 +14,8 @@ export interface BaseProviderConfig extends BaseConfig {
 export declare abstract class BaseProvider<C extends BaseProviderConfig, S extends BaseProviderState, P> extends BaseController<C, S, BaseProviderEvents<S>> implements IBaseProvider<P> {
     _providerEngineProxy: SafeEventEmitterProvider<ProviderEvents> | null;
     private keyExportFlagSetByCode;
+    private providerEventBridges;
+    private providerListenerBridgeRegistered;
     constructor({ config, state }: {
         config: C;
         state?: S;
@@ -30,6 +32,11 @@ export declare abstract class BaseProvider<C extends BaseProviderConfig, S exten
     setKeyExportFlag(flag: boolean): void;
     protected getProviderEngineProxy(): SafeEventEmitterProvider | null;
     protected getChain(chainId: string): CustomChainConfig;
+    private ensureProviderListenerBridge;
+    private ensureProviderEventBridge;
+    private attachProviderEventBridges;
+    private attachProviderEventBridge;
+    private detachProviderEventBridges;
     abstract setupProvider(provider: P, chainId: string): Promise<void>;
     abstract switchChain(params: {
         chainId: string;

package/dist/lib.cjs/types/react/hooks/index.d.ts

@@ -8,6 +8,7 @@ export * from "./useReceive";
 export * from "./useSwap";
 export * from "./useSwitchChain";
 export * from "./useWalletConnectScanner";
+export * from "./useWallets";
 export * from "./useWalletServicesPlugin";
 export * from "./useWalletUI";
 export * from "./useWeb3Auth";

package/dist/lib.cjs/types/react/hooks/useWallets.d.ts

@@ -0,0 +1,8 @@
+import { ConnectedAccountsWithProviders, Web3AuthError } from "../../base";
+export interface IUseWallets {
+    loading: boolean;
+    error: Web3AuthError | null;
+    wallets: ConnectedAccountsWithProviders[];
+    syncWallets(): Promise<void>;
+}
+export declare const useWallets: () => IUseWallets;

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

@@ -9,6 +9,7 @@ export * from "./useReceive";
 export * from "./useSwap";
 export * from "./useSwitchChain";
 export * from "./useWalletConnectScanner";
+export * from "./useWallets";
 export * from "./useWalletServicesPlugin";
 export * from "./useWalletUI";
 export * from "./useWeb3Auth";

package/dist/lib.cjs/types/vue/composables/useWallets.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from "vue";
+import { type ConnectedAccountsWithProviders, Web3AuthError } from "../../base";
+export interface IUseWallets {
+    loading: Ref<boolean>;
+    error: Ref<Web3AuthError | null>;
+    wallets: Ref<ConnectedAccountsWithProviders[]>;
+    syncWallets(): Promise<void>;
+}
+export declare const useWallets: () => IUseWallets;

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

@@ -0,0 +1,52 @@
+'use strict';
+
+var vue = require('vue');
+require('@babel/runtime/helpers/objectSpread2');
+require('@babel/runtime/helpers/defineProperty');
+require('@segment/analytics-next');
+var loglevel = require('../../base/loglevel.js');
+require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
+require('@web3auth/auth');
+var index = require('../../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../base/constants.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/connectorStatus.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useWallets = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const wallets = vue.ref([]);
+  const syncWallets = async () => {
+    if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+    error.value = null;
+    loading.value = true;
+    try {
+      const result = await web3Auth.value.getConnectedAccountsWithProviders();
+      wallets.value = result;
+    } catch (err) {
+      loglevel.log.error("Error getting wallets", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    wallets,
+    syncWallets
+  };
+};
+
+exports.useWallets = useWallets;

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

@@ -34,7 +34,7 @@ const useWeb3AuthConnect = () => {
     }
     if (newVal && !connectorName.value) {
       var _web3Auth$value;
-      connectorName.value = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.connectedConnectorName;
+      connectorName.value = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.primaryConnectorName;
     }
   }, {
     immediate: true
@@ -45,7 +45,7 @@ const useWeb3AuthConnect = () => {
       error.value = null;
       loading.value = true;
       const localProvider = await web3Auth.value.connectTo(connectorType, loginParams);
-      connectorName.value = web3Auth.value.connectedConnectorName;
+      connectorName.value = web3Auth.value.primaryConnectorName;
       return localProvider;
     } catch (err) {
       loglevel.log.error("Error connecting", err);

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

@@ -11,6 +11,7 @@ var useReceive = require('./composables/useReceive.js');
 var useSwap = require('./composables/useSwap.js');
 var useSwitchChain = require('./composables/useSwitchChain.js');
 var useWalletConnectScanner = require('./composables/useWalletConnectScanner.js');
+var useWallets = require('./composables/useWallets.js');
 var useWalletServicesPlugin = require('./composables/useWalletServicesPlugin.js');
 var useWalletUI = require('./composables/useWalletUI.js');
 var useWeb3Auth = require('./composables/useWeb3Auth.js');
@@ -35,6 +36,7 @@ exports.useReceive = useReceive.useReceive;
 exports.useSwap = useSwap.useSwap;
 exports.useSwitchChain = useSwitchChain.useSwitchChain;
 exports.useWalletConnectScanner = useWalletConnectScanner.useWalletConnectScanner;
+exports.useWallets = useWallets.useWallets;
 exports.useWalletServicesPlugin = useWalletServicesPlugin.useWalletServicesPlugin;
 exports.useWalletUI = useWalletUI.useWalletUI;
 exports.useWeb3Auth = useWeb3Auth.useWeb3Auth;

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

@@ -66,12 +66,12 @@ const useSolanaWallet = () => {
   };
   vue.onScopeDispose(teardownWalletListeners);
   const getPrivateKey = async () => {
-    var _connection$value2, _web3Auth$value$conne;
+    var _connection$value2, _web3Auth$value$prima;
     if (!web3Auth.value) throw new Error("Web3Auth not initialized");
     if (((_connection$value2 = connection.value) === null || _connection$value2 === void 0 ? void 0 : _connection$value2.connectorName) !== index.WALLET_CONNECTORS.AUTH) {
       throw new Error("getPrivateKey is only supported with the Auth connector");
     }
-    const provider = (_web3Auth$value$conne = web3Auth.value.connectedConnector) === null || _web3Auth$value$conne === void 0 ? void 0 : _web3Auth$value$conne.provider;
+    const provider = (_web3Auth$value$prima = web3Auth.value.primaryConnector) === null || _web3Auth$value$prima === void 0 ? void 0 : _web3Auth$value$prima.provider;
     if (!provider) throw new Error("Provider not available");
     const privateKey = await provider.request({
       method: wsEmbed.SOLANA_METHOD_TYPES.SOLANA_PRIVATE_KEY

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

@@ -19,6 +19,7 @@ require('../../base/connector/constants.js');
 require('jwt-decode');
 require('../../base/plugin/errors.js');
 require('../../base/plugin/IPlugin.js');
+var useChain = require('../composables/useChain.js');
 var useWeb3Auth = require('../composables/useWeb3Auth.js');
 var constants = require('./constants.js');
 
@@ -45,55 +46,81 @@ const SolanaProvider = vue.defineComponent({
       connection,
       web3Auth
     } = useWeb3Auth.useWeb3Auth();
+    const {
+      chainId
+    } = useChain.useChain();
     const clientRef = vue.ref(null);
+    // Holds the token for the newest requested sync run. Older async runs compare against it
+    // before publishing results so a slower reconnect cannot overwrite a newer chain/account update.
+    let activeSyncToken = null;
     // provide the client to the app
     vue.provide(constants.SOLANA_CLIENT_KEY, clientRef);
-    // watch for changes in the connection and chain namespace
-    vue.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;
+    const syncClient = async () => {
+      var _web3Auth$value, _web3Auth$value2;
+      // Only the latest async, `syncing` run should be allowed to attach its client.
+      // A fresh Symbol gives each run a unique identity without relying on counters.
+      const syncToken = Symbol("solana-client-sync");
+      activeSyncToken = syncToken;
+      const newIsConnected = isConnected.value;
+      const newConnection = connection.value;
+      const currentChain = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.currentChain;
+      if (!newIsConnected || !(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet) || (currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) !== baseControllers.CHAIN_NAMESPACES.SOLANA ||
+      // only reconnect for the primary connector
+      newConnection.connectorName !== ((_web3Auth$value2 = web3Auth.value) === null || _web3Auth$value2 === void 0 ? void 0 : _web3Auth$value2.primaryConnectorName)) {
+        const prevClient = clientRef.value;
+        clientRef.value = null;
+        if (prevClient) {
+          await disposeClient(prevClient);
         }
         return;
       }
-      const currentChain = web3Auth.value.currentChain;
-      let chainConfig;
-      if ((currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) === baseControllers.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 === baseControllers.CHAIN_NAMESPACES.SOLANA);
-        if (!chainConfig) return;
-      }
       const prevClient = clientRef.value;
+      clientRef.value = null;
+      if (prevClient) {
+        await disposeClient(prevClient);
+      }
+      let client$1 = null;
       try {
         // create a wallet standard connector from connected wallet
-        const solanaWalletId = "wallet-standard:" + connection.value.connectorName;
-        const connector = client.createWalletStandardConnector(connection.value.solanaWallet, {
+        const solanaWalletId = "wallet-standard:" + newConnection.connectorName;
+        const connector = client.createWalletStandardConnector(newConnection.solanaWallet, {
           id: solanaWalletId,
-          name: connection.value.connectorName
+          name: newConnection.connectorName
         });
         // create a solana client
         const {
           rpcTarget,
           wsTarget
-        } = chainConfig;
-        const client$1 = client.createClient({
+        } = currentChain;
+        client$1 = client.createClient({
           endpoint: rpcTarget,
           websocketEndpoint: wsTarget,
           walletConnectors: [connector]
         });
-        clientRef.value = client$1;
-        if (prevClient) await disposeClient(prevClient);
         // connect the client to the wallet
         await client$1.actions.connectWallet(solanaWalletId, {
           autoConnect: true
         });
+        // If another sync started while connectWallet was in flight, this client is stale.
+        if (activeSyncToken !== syncToken) {
+          await disposeClient(client$1);
+          return;
+        }
+        clientRef.value = client$1;
       } catch (err) {
+        if (client$1) {
+          await disposeClient(client$1);
+        }
         loglevel.log.error("Failed to create or connect Solana client", err);
-        clientRef.value = null;
+        // Only clear the shared ref when this failing run is still the newest one.
+        if (activeSyncToken === syncToken) {
+          clientRef.value = null;
+        }
       }
+    };
+    // watch for changes in the connection and active chain
+    vue.watch([isConnected, connection, chainId], () => {
+      void syncClient();
     }, {
       immediate: true
     });

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

@@ -105,7 +105,7 @@ function useWeb3AuthInnerContextValue({
         var _web3Auth$value$curre, _web3Auth$value$curre2;
         if (!isInitialized.value) isInitialized.value = true;
         isConnected.value = true;
-        connection.value = newWeb3Auth.connection;
+        connection.value = web3Auth.value.connection;
         chainId.value = web3Auth.value.currentChainId;
         chainNamespace.value = (_web3Auth$value$curre = (_web3Auth$value$curre2 = web3Auth.value.currentChain) === null || _web3Auth$value$curre2 === void 0 ? void 0 : _web3Auth$value$curre2.chainNamespace) !== null && _web3Auth$value$curre !== void 0 ? _web3Auth$value$curre : null;
       }
@@ -123,7 +123,7 @@ function useWeb3AuthInnerContextValue({
         var _web3Auth$value$curre3, _web3Auth$value$curre4;
         if (!isInitialized.value) isInitialized.value = true;
         isConnected.value = true;
-        connection.value = newWeb3Auth.connection;
+        connection.value = web3Auth.value.connection;
         chainId.value = web3Auth.value.currentChainId;
         chainNamespace.value = (_web3Auth$value$curre3 = (_web3Auth$value$curre4 = web3Auth.value.currentChain) === null || _web3Auth$value$curre4 === void 0 ? void 0 : _web3Auth$value$curre4.chainNamespace) !== null && _web3Auth$value$curre3 !== void 0 ? _web3Auth$value$curre3 : null;
         if (web3Auth.value.status === constants.CONNECTOR_STATUS.AUTHORIZED) {
@@ -147,6 +147,13 @@ function useWeb3AuthInnerContextValue({
     const mfaEnabledListener = () => {
       isMFAEnabled.value = true;
     };
+    const connectionUpdatedListener = () => {
+      var _web3Auth$value$curre5, _web3Auth$value$curre6;
+      status.value = web3Auth.value.status;
+      connection.value = web3Auth.value.connection;
+      chainId.value = web3Auth.value.currentChainId;
+      chainNamespace.value = (_web3Auth$value$curre5 = (_web3Auth$value$curre6 = web3Auth.value.currentChain) === null || _web3Auth$value$curre6 === void 0 ? void 0 : _web3Auth$value$curre6.chainNamespace) !== null && _web3Auth$value$curre5 !== void 0 ? _web3Auth$value$curre5 : null;
+    };
     if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
       prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.NOT_READY, notReadyListener);
       prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.READY, readyListener);
@@ -157,6 +164,7 @@ function useWeb3AuthInnerContextValue({
       prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
       prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
       prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
       if (prevWeb3Auth.loginMode === constants$1.LOGIN_MODE.MODAL) {
         prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }
@@ -172,6 +180,7 @@ function useWeb3AuthInnerContextValue({
       newWeb3Auth.on(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
       newWeb3Auth.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
       newWeb3Auth.on(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
       if (newWeb3Auth.loginMode === constants$1.LOGIN_MODE.MODAL) {
         newWeb3Auth.on(constants.CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }
@@ -182,9 +191,9 @@ function useWeb3AuthInnerContextValue({
   vue.watch(connection, (newConnection, prevConnection) => {
     var _prevConnection$ether, _newConnection$ethere;
     const handleChainChange = newChainId => {
-      var _web3Auth$value$curre5, _web3Auth$value;
+      var _web3Auth$value$curre7, _web3Auth$value;
       chainId.value = newChainId;
-      chainNamespace.value = (_web3Auth$value$curre5 = (_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$curre5 !== void 0 ? _web3Auth$value$curre5 : null;
+      chainNamespace.value = (_web3Auth$value$curre7 = (_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$curre7 !== void 0 ? _web3Auth$value$curre7 : 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;

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

@@ -89,7 +89,8 @@ const Web3AuthWagmiProvider = vue.defineComponent({
   setup() {
     const {
       isConnected,
-      connection
+      connection,
+      chainNamespace
     } = useWeb3Auth.useWeb3Auth();
     const {
       disconnect
@@ -98,10 +99,15 @@ const Web3AuthWagmiProvider = vue.defineComponent({
     const {
       mutate: reconnect
     } = vue$1.useReconnect();
+    const lastSyncedProvider = vue.shallowRef(null);
+    const lastSyncedConnectorName = vue.ref(null);
+    const suppressWagmiDisconnect = vue.ref(false);
     vue$1.useConnectionEffect({
       onDisconnect: async () => {
         loglevel.log.info("Disconnected from wagmi");
-        if (isConnected.value) await disconnect();
+        const isSuppressed = suppressWagmiDisconnect.value;
+        suppressWagmiDisconnect.value = false;
+        if (!isSuppressed && isConnected.value) await disconnect();
         const connector = getWeb3authConnector(wagmiConfig);
         // reset wagmi connector state if the provider handles disconnection because of the accountsChanged event
         // from the connected provider
@@ -110,19 +116,41 @@ const Web3AuthWagmiProvider = vue.defineComponent({
         }
       }
     });
-    vue.watch([isConnected, connection], async () => {
-      var _connection$value;
+    vue.watch([isConnected, connection, chainNamespace], async () => {
+      var _newConnection$ethere;
       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);
+      const newConnection = connection.value;
+      const newEth = (_newConnection$ethere = newConnection === null || newConnection === void 0 ? void 0 : newConnection.ethereumProvider) !== null && _newConnection$ethere !== void 0 ? _newConnection$ethere : null;
+      const shouldBindToWagmi = newIsConnected && chainNamespace.value === baseControllers.CHAIN_NAMESPACES.EIP155 && Boolean(newConnection && newEth);
+      if (shouldBindToWagmi && newConnection && newEth) {
+        const hasSameBinding = lastSyncedProvider.value === newEth && lastSyncedConnectorName.value === newConnection.connectorName;
+        if (hasSameBinding && wagmiConfig.state.status === "connected") {
+          return;
+        }
+        if (!hasSameBinding && getWeb3authConnector(wagmiConfig)) {
+          if (wagmiConfig.state.status === "connected") {
+            suppressWagmiDisconnect.value = true;
+            await disconnectWeb3AuthFromWagmi(wagmiConfig);
+          } else {
+            resetConnectorState(wagmiConfig);
+          }
+        }
+        const connector = await setupConnector(newEth, wagmiConfig);
         if (!connector) {
           throw new Error("Failed to setup connector");
         }
         await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+        lastSyncedProvider.value = newEth;
+        lastSyncedConnectorName.value = newConnection.connectorName;
         reconnect();
-      } else if (!newIsConnected) {
+      } else {
+        lastSyncedProvider.value = null;
+        lastSyncedConnectorName.value = null;
         if (wagmiConfig.state.status === "connected") {
+          suppressWagmiDisconnect.value = true;
           await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        } else if (getWeb3authConnector(wagmiConfig)) {
+          resetConnectorState(wagmiConfig);
         }
       }
     }, {

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

@@ -0,0 +1 @@
+export { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from './rest.js';

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

@@ -0,0 +1,74 @@
+import { useState, useCallback } from 'react';
+import { useWeb3AuthInner } from '../react/hooks/useWeb3AuthInner.js';
+import { WalletInitializationError } from '../base/errors/index.js';
+export { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from './rest.js';
+
+const useLinkAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [linkedAccounts, setLinkedAccounts] = useState([]);
+  const linkAccount = useCallback(async params => {
+    if (!web3Auth) throw WalletInitializationError.notReady();
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await web3Auth.linkAccount(params);
+      setLinkedAccounts(result.linkedAccounts);
+      return result;
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  const unlinkAccount = useCallback(async address => {
+    if (!web3Auth) throw WalletInitializationError.notReady();
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await web3Auth.unlinkAccount(address);
+      setLinkedAccounts(result.linkedAccounts);
+      return result;
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    linkAccount,
+    unlinkAccount,
+    linkedAccounts
+  };
+};
+const useSwitchAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const switchAccount = useCallback(async account => {
+    if (!web3Auth) throw WalletInitializationError.notReady();
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.switchAccount(account);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    switchAccount
+  };
+};
+
+export { useLinkAccount, useSwitchAccount };

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

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

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

@@ -0,0 +1,78 @@
+import { ref } from 'vue';
+import { useWeb3AuthInner } from '../vue/composables/useWeb3AuthInner.js';
+import { WalletInitializationError } from '../base/errors/index.js';
+import { log } from '../base/loglevel.js';
+export { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from './rest.js';
+
+const useLinkAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const loading = ref(false);
+  const error = ref(null);
+  const linkedAccounts = ref([]);
+  const linkAccount = async params => {
+    if (!web3Auth.value) throw WalletInitializationError.notReady();
+    try {
+      error.value = null;
+      loading.value = true;
+      const result = await web3Auth.value.linkAccount(params);
+      linkedAccounts.value = result.linkedAccounts;
+      return result;
+    } catch (err) {
+      log.error("Error linking account", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const unlinkAccount = async address => {
+    if (!web3Auth.value) throw WalletInitializationError.notReady();
+    try {
+      error.value = null;
+      loading.value = true;
+      const result = await web3Auth.value.unlinkAccount(address);
+      linkedAccounts.value = result.linkedAccounts;
+      return result;
+    } catch (err) {
+      log.error("Error unlinking account", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    linkAccount,
+    unlinkAccount,
+    linkedAccounts
+  };
+};
+const useSwitchAccount = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const loading = ref(false);
+  const error = ref(null);
+  const switchAccount = async account => {
+    if (!web3Auth.value) throw WalletInitializationError.notReady();
+    error.value = null;
+    loading.value = true;
+    try {
+      await web3Auth.value.switchAccount(account);
+    } catch (err) {
+      log.error("Error switching account", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    switchAccount
+  };
+};
+
+export { useLinkAccount, useSwitchAccount };

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

@@ -11,6 +11,9 @@ class Analytics {
     _defineProperty(this, "enabled", true);
   }
   init() {
+    if (!this.enabled) {
+      return;
+    }
     if (this.isSkipped()) {
       return;
     }
@@ -74,7 +77,7 @@ class Analytics {
   isSkipped() {
     const dappOrigin = window.location.origin;
 
-    // skip if the protocol is not http or https
+    // skip if the protocol is http
     if (dappOrigin.startsWith("http://")) {
       return true;
     }
@@ -115,7 +118,19 @@ const ANALYTICS_EVENTS = {
   WALLET_FUNDING_CLICKED: "Wallet Funding Clicked",
   WALLET_CHECKOUT_CLICKED: "Wallet Checkout Clicked",
   WALLET_RECEIVE_CLICKED: "Wallet Receive Clicked",
-  WALLET_SWAP_CLICKED: "Wallet Swap Clicked"
+  WALLET_SWAP_CLICKED: "Wallet Swap Clicked",
+  // Account Linking
+  ACCOUNT_LINKING_STARTED: "Account Linking Started",
+  ACCOUNT_LINKING_COMPLETED: "Account Linking Completed",
+  ACCOUNT_LINKING_FAILED: "Account Linking Failed",
+  // Account Unlinking
+  ACCOUNT_UNLINKING_STARTED: "Account Unlinking Started",
+  ACCOUNT_UNLINKING_COMPLETED: "Account Unlinking Completed",
+  ACCOUNT_UNLINKING_FAILED: "Account Unlinking Failed",
+  // Account switch (active connected wallet)
+  ACCOUNT_SWITCH_STARTED: "Account Switch Started",
+  ACCOUNT_SWITCH_COMPLETED: "Account Switch Completed",
+  ACCOUNT_SWITCH_FAILED: "Account Switch Failed"
 };
 const ANALYTICS_INTEGRATION_TYPE = {
   REACT_HOOKS: "React Hooks",