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

package/dist/lib.cjs/react/hooks/useWalletUI.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var react = require('react');
+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 useWalletUI = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin.useWalletServicesPlugin();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const showWalletUI = react.useCallback(async showWalletUiParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw errors.WalletServicesPluginError.notInitialized();
+      if (!ready) throw errors.WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showWalletUi(showWalletUiParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showWalletUI
+  };
+};
+
+exports.useWalletUI = useWalletUI;

package/dist/lib.cjs/react/hooks/useWeb3Auth.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useWeb3Auth = () => {
+  const {
+    initError,
+    isConnected,
+    isInitialized,
+    isInitializing,
+    provider,
+    status,
+    web3Auth,
+    getPlugin
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  return {
+    initError,
+    isConnected,
+    isInitialized,
+    isInitializing,
+    provider,
+    status,
+    web3Auth,
+    getPlugin
+  };
+};
+
+exports.useWeb3Auth = useWeb3Auth;

package/dist/lib.cjs/react/hooks/useWeb3AuthConnect.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var react = require('react');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useWeb3AuthConnect = () => {
+  const context = useWeb3AuthInner.useWeb3AuthInner();
+  const {
+    web3Auth,
+    isConnected
+  } = context;
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [connectorName, setConnectorName] = react.useState(null);
+  react.useEffect(() => {
+    if (!web3Auth) return;
+    if (!isConnected && connectorName) {
+      setConnectorName(null);
+    }
+    if (isConnected && !connectorName) {
+      setConnectorName(web3Auth.connectedConnectorName);
+    }
+  }, [isConnected, connectorName, web3Auth]);
+  const connect = react.useCallback(async (connector, params) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const provider = await web3Auth.connectTo(connector, params);
+      if (provider) {
+        setConnectorName(web3Auth.connectedConnectorName);
+      }
+      return provider;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    isConnected,
+    loading,
+    error,
+    connectorName,
+    connect
+  };
+};
+
+exports.useWeb3AuthConnect = useWeb3AuthConnect;

package/dist/lib.cjs/react/hooks/useWeb3AuthDisconnect.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var react = require('react');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useWeb3AuthDisconnect = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const disconnect = react.useCallback(async options => {
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.logout(options);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    disconnect
+  };
+};
+
+exports.useWeb3AuthDisconnect = useWeb3AuthDisconnect;

package/dist/lib.cjs/react/{no-modal/hooks/useWeb3Auth.js → hooks/useWeb3AuthInner.js}

@@ -4,18 +4,18 @@ var react = require('react');
 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');
+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('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
 require('@toruslabs/constants');
 require('@toruslabs/http-helpers');
-var Web3AuthInnerContext = require('../Web3AuthInnerContext.js');
+var Web3AuthInnerContext = require('../context/Web3AuthInnerContext.js');
 
-const useWeb3Auth = () => {
+const useWeb3AuthInner = () => {
   const context = react.useContext(Web3AuthInnerContext.Web3AuthInnerContext);
   if (!context) {
     throw index.WalletInitializationError.fromCode(1000, "usage of useWeb3Auth not wrapped in `Web3AuthContextProvider`.");
@@ -23,4 +23,4 @@ const useWeb3Auth = () => {
   return context;
 };
 
-exports.useWeb3Auth = useWeb3Auth;
+exports.useWeb3AuthInner = useWeb3AuthInner;

package/dist/lib.cjs/react/hooks/useWeb3AuthUser.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var react = require('react');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useWeb3AuthUser = () => {
+  const {
+    web3Auth,
+    isConnected,
+    isMFAEnabled,
+    setIsMFAEnabled
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [userInfo, setUserInfo] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const getUserInfo = react.useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const userInfo = await web3Auth.getUserInfo();
+      setUserInfo(userInfo);
+      return userInfo;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  react.useEffect(() => {
+    const saveUserInfo = async () => {
+      const userInfo = await getUserInfo();
+      setUserInfo(userInfo);
+      setIsMFAEnabled((userInfo === null || userInfo === void 0 ? void 0 : userInfo.isMfaEnabled) || false);
+    };
+    if (isConnected && !userInfo) saveUserInfo();
+    if (!isConnected && userInfo) {
+      setUserInfo(null);
+      setIsMFAEnabled(false);
+    }
+  }, [isConnected, userInfo, getUserInfo, setIsMFAEnabled]);
+  return {
+    loading,
+    error,
+    userInfo,
+    isMFAEnabled,
+    getUserInfo
+  };
+};
+
+exports.useWeb3AuthUser = useWeb3AuthUser;

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

@@ -1,16 +1,33 @@
 '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');
+var useCheckout = require('./hooks/useCheckout.js');
+var useEnableMFA = require('./hooks/useEnableMFA.js');
+var useIdentityToken = require('./hooks/useIdentityToken.js');
+var useManageMFA = require('./hooks/useManageMFA.js');
+var useSwap = require('./hooks/useSwap.js');
+var useSwitchChain = require('./hooks/useSwitchChain.js');
+var useWalletConnectScanner = require('./hooks/useWalletConnectScanner.js');
+var useWalletServicesPlugin = require('./hooks/useWalletServicesPlugin.js');
+var useWalletUI = require('./hooks/useWalletUI.js');
+var useWeb3Auth = require('./hooks/useWeb3Auth.js');
+var useWeb3AuthConnect = require('./hooks/useWeb3AuthConnect.js');
+var useWeb3AuthDisconnect = require('./hooks/useWeb3AuthDisconnect.js');
+var useWeb3AuthUser = require('./hooks/useWeb3AuthUser.js');
+var Web3AuthProvider = require('./Web3AuthProvider.js');
 
 
 
+exports.useCheckout = useCheckout.useCheckout;
+exports.useEnableMFA = useEnableMFA.useEnableMFA;
+exports.useIdentityToken = useIdentityToken.useIdentityToken;
+exports.useManageMFA = useManageMFA.useManageMFA;
+exports.useSwap = useSwap.useSwap;
+exports.useSwitchChain = useSwitchChain.useSwitchChain;
+exports.useWalletConnectScanner = useWalletConnectScanner.useWalletConnectScanner;
+exports.useWalletServicesPlugin = useWalletServicesPlugin.useWalletServicesPlugin;
+exports.useWalletUI = useWalletUI.useWalletUI;
 exports.useWeb3Auth = useWeb3Auth.useWeb3Auth;
+exports.useWeb3AuthConnect = useWeb3AuthConnect.useWeb3AuthConnect;
+exports.useWeb3AuthDisconnect = useWeb3AuthDisconnect.useWeb3AuthDisconnect;
+exports.useWeb3AuthUser = useWeb3AuthUser.useWeb3AuthUser;
 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/solana/hooks/useSignAndSendTransaction.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var react = require('react');
+var useSolanaWallet = require('./useSolanaWallet.js');
+
+const useSignAndSendTransaction = () => {
+  const {
+    solanaWallet
+  } = useSolanaWallet.useSolanaWallet();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [data, setData] = react.useState(null);
+  const signAndSendTransaction = react.useCallback(async transaction => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!solanaWallet) throw new Error("Solana wallet not found");
+      const signature = await solanaWallet.signAndSendTransaction(transaction);
+      setData(signature);
+      return signature;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [solanaWallet]);
+  return {
+    loading,
+    error,
+    data,
+    signAndSendTransaction
+  };
+};
+
+exports.useSignAndSendTransaction = useSignAndSendTransaction;

package/dist/lib.cjs/react/solana/hooks/useSignMessage.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var react = require('react');
+var useSolanaWallet = require('./useSolanaWallet.js');
+
+const useSignMessage = () => {
+  const {
+    solanaWallet,
+    accounts
+  } = useSolanaWallet.useSolanaWallet();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [data, setData] = react.useState(null);
+  const signMessage = react.useCallback(async (message, from) => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!solanaWallet) throw new Error("Solana wallet not found");
+      const signature = await solanaWallet.signMessage(message, from !== null && from !== void 0 ? from : accounts === null || accounts === void 0 ? void 0 : accounts[0]);
+      setData(signature);
+      return signature;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [solanaWallet, accounts]);
+  return {
+    loading,
+    error,
+    data,
+    signMessage
+  };
+};
+
+exports.useSignMessage = useSignMessage;

package/dist/lib.cjs/react/solana/hooks/useSignTransaction.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var react = require('react');
+var useSolanaWallet = require('./useSolanaWallet.js');
+
+const useSignTransaction = () => {
+  const {
+    solanaWallet
+  } = useSolanaWallet.useSolanaWallet();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [data, setData] = react.useState(null);
+  const signTransaction = react.useCallback(async transaction => {
+    setLoading(true);
+    setError(null);
+    try {
+      const signedTransaction = await solanaWallet.signTransaction(transaction);
+      setData(signedTransaction);
+      return signedTransaction;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [solanaWallet]);
+  return {
+    loading,
+    error,
+    data,
+    signTransaction
+  };
+};
+
+exports.useSignTransaction = useSignTransaction;

package/dist/lib.cjs/react/solana/hooks/useSolanaWallet.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var web3_js = require('@solana/web3.js');
+var react = require('react');
+var baseControllers = require('@toruslabs/base-controllers');
+require('@solana/wallet-standard-features');
+require('@toruslabs/bs58');
+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');
+require('../../../base/plugin/errors.js');
+require('../../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('@babel/runtime/helpers/objectSpread2');
+require('../../../providers/base-provider/utils.js');
+require('../../../providers/base-provider/CommonJRPCProvider.js');
+require('../../../providers/base-provider/commonPrivateKeyProvider.js');
+require('@web3auth/ws-embed');
+var solanaWallet = require('../../../providers/solana-provider/solanaWallet.js');
+var useWeb3Auth = require('../../hooks/useWeb3Auth.js');
+
+const useSolanaWallet = () => {
+  const {
+    provider,
+    web3Auth
+  } = useWeb3Auth.useWeb3Auth();
+  const [accounts, setAccounts] = react.useState(null);
+  const solanaWallet$1 = react.useMemo(() => {
+    if (!provider) return null;
+    return new solanaWallet.SolanaWallet(provider);
+  }, [provider]);
+  const connection = react.useMemo(() => {
+    if (!web3Auth || !provider) return null;
+    return new web3_js.Connection(web3Auth.currentChain.rpcTarget);
+  }, [web3Auth, provider]);
+  react.useEffect(() => {
+    const init = async () => {
+      var _web3Auth$currentChai;
+      if (!solanaWallet$1) return;
+      if (!(web3Auth !== null && web3Auth !== void 0 && (_web3Auth$currentChai = web3Auth.currentChain) !== null && _web3Auth$currentChai !== void 0 && _web3Auth$currentChai.chainNamespace) || web3Auth.currentChain.chainNamespace !== baseControllers.CHAIN_NAMESPACES.SOLANA) {
+        return;
+      }
+      const accounts = await solanaWallet$1.requestAccounts();
+      if ((accounts === null || accounts === void 0 ? void 0 : accounts.length) > 0) {
+        setAccounts(accounts);
+      }
+    };
+    if (solanaWallet$1) init();
+  }, [solanaWallet$1]);
+  return {
+    solanaWallet: solanaWallet$1,
+    accounts,
+    connection
+  };
+};
+
+exports.useSolanaWallet = useSolanaWallet;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var useSignAndSendTransaction = require('./hooks/useSignAndSendTransaction.js');
+var useSignMessage = require('./hooks/useSignMessage.js');
+var useSignTransaction = require('./hooks/useSignTransaction.js');
+var useSolanaWallet = require('./hooks/useSolanaWallet.js');
+
+
+
+exports.useSignAndSendTransaction = useSignAndSendTransaction.useSignAndSendTransaction;
+exports.useSignMessage = useSignMessage.useSignMessage;
+exports.useSignTransaction = useSignTransaction.useSignTransaction;
+exports.useSolanaWallet = useSolanaWallet.useSolanaWallet;

package/dist/lib.cjs/react/wagmi/constants.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var wagmi = require('wagmi');
+var chains = require('wagmi/chains');
+
+const defaultWagmiConfig = wagmi.createConfig({
+  chains: [chains.mainnet],
+  connectors: [],
+  // or your basic wallets
+  ssr: true,
+  transports: {
+    [chains.mainnet.id]: wagmi.http(chains.mainnet.rpcUrls.default.http[0])
+  }
+});
+
+exports.defaultWagmiConfig = defaultWagmiConfig;

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

@@ -0,0 +1,7 @@
+'use strict';
+
+var provider = require('./provider.js');
+
+
+
+exports.WagmiProvider = provider.WagmiProvider;

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

@@ -0,0 +1,189 @@
+'use strict';
+
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var react = require('react');
+var viem = require('viem');
+var wagmi = require('wagmi');
+var connectors = require('wagmi/connectors');
+var baseControllers = 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');
+var loglevel = require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../context/WalletServicesInnerContext.js');
+require('../context/Web3AuthInnerContext.js');
+var useWeb3Auth = require('../hooks/useWeb3Auth.js');
+var useWeb3AuthDisconnect = require('../hooks/useWeb3AuthDisconnect.js');
+var constants = require('./constants.js');
+
+const _excluded = ["children"];
+const WEB3AUTH_CONNECTOR_ID = "web3auth";
+// Helper to initialize connectors for the given wallets
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function setupConnector(provider, config) {
+  let connector = config.connectors.find(c => c.id === WEB3AUTH_CONNECTOR_ID);
+  if (connector) return connector;
+  // Create new connector if not already existing
+  connector = connectors.injected({
+    target: {
+      provider: provider,
+      id: WEB3AUTH_CONNECTOR_ID,
+      name: "Web3Auth"
+    }
+  });
+  const result = config._internal.connectors.setup(connector);
+  config._internal.connectors.setState(current => [...current, result]);
+  return result;
+}
+// Helper to connect a wallet and update wagmi state
+async function connectWeb3AuthWithWagmi(connector, config) {
+  var _config$storage, _config$storage2;
+  await Promise.all([(_config$storage = config.storage) === null || _config$storage === void 0 ? void 0 : _config$storage.removeItem(`${connector.id}.disconnected`), (_config$storage2 = config.storage) === null || _config$storage2 === void 0 ? void 0 : _config$storage2.setItem("recentConnectorId", connector.id)]);
+  let chainId = await connector.getChainId();
+  if (!config.chains.find(c => c.id === chainId)) {
+    chainId = config.chains[0].id;
+  }
+  const accounts = await connector.getAccounts();
+  const connections = new Map([[connector.uid, {
+    accounts: [accounts[0]],
+    chainId,
+    connector
+  }]]);
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId,
+    connections,
+    current: connector.uid,
+    status: "connected"
+  }));
+}
+async function disconnectWeb3AuthFromWagmi(config) {
+  config._internal.connectors.setState(prev => prev.filter(c => c.id !== WEB3AUTH_CONNECTOR_ID));
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId: state.chainId,
+    connections: new Map(),
+    current: undefined,
+    status: "disconnected"
+  }));
+}
+function Web3AuthWagmiProvider({
+  children
+}) {
+  const {
+    isConnected,
+    provider
+  } = useWeb3Auth.useWeb3Auth();
+  const {
+    disconnect
+  } = useWeb3AuthDisconnect.useWeb3AuthDisconnect();
+  const wagmiConfig = wagmi.useConfig();
+  const {
+    reconnect
+  } = wagmi.useReconnect();
+  wagmi.useAccountEffect({
+    onDisconnect: async () => {
+      loglevel.log.info("Disconnected from wagmi");
+      if (isConnected) await disconnect();
+    }
+  });
+  react.useEffect(() => {
+    (async () => {
+      if (isConnected && provider) {
+        const connector = await setupConnector(provider, wagmiConfig);
+        if (!connector) {
+          throw new Error("Failed to setup connector");
+        }
+        await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+        reconnect();
+      } else if (!isConnected) {
+        if (wagmiConfig.state.status === "connected") {
+          await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        }
+      }
+    })();
+  }, [isConnected, wagmiConfig, provider, reconnect]);
+  return react.createElement(react.Fragment, null, children);
+}
+function WagmiProvider(_ref) {
+  let {
+      children
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const {
+    config
+  } = props;
+  const {
+    web3Auth,
+    isInitialized
+  } = useWeb3Auth.useWeb3Auth();
+  const finalConfig = react.useMemo(() => {
+    var _web3Auth$coreOptions;
+    if (!isInitialized) return constants.defaultWagmiConfig;
+    const finalConfig = _objectSpread(_objectSpread({
+      ssr: true
+    }, config), {}, {
+      chains: undefined,
+      connectors: [],
+      transports: {},
+      multiInjectedProviderDiscovery: false,
+      client: undefined
+    });
+    const wagmiChains = [];
+    if (isInitialized && web3Auth !== null && web3Auth !== void 0 && (_web3Auth$coreOptions = web3Auth.coreOptions) !== null && _web3Auth$coreOptions !== void 0 && _web3Auth$coreOptions.chains) {
+      var _web3Auth$currentChai;
+      const defaultChainId = (_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainId;
+      const chains = web3Auth.coreOptions.chains.filter(chain => chain.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155);
+      if (chains.length === 0) throw index.WalletInitializationError.invalidParams("No valid chains found in web3auth config for wagmi.");
+      chains.forEach(chain => {
+        const wagmiChain = viem.defineChain({
+          id: Number.parseInt(chain.chainId, 16),
+          // id in number form
+          name: chain.displayName,
+          rpcUrls: {
+            default: {
+              http: [chain.rpcTarget],
+              webSocket: [chain.wsTarget]
+            }
+          },
+          blockExplorers: chain.blockExplorerUrl ? {
+            default: {
+              name: "explorer",
+              // TODO: correct name if chain config has it
+              url: chain.blockExplorerUrl
+            }
+          } : undefined,
+          nativeCurrency: {
+            name: chain.tickerName,
+            symbol: chain.ticker,
+            decimals: chain.decimals || 18
+          }
+        });
+        if (defaultChainId === chain.chainId) {
+          wagmiChains.unshift(wagmiChain);
+        } else {
+          wagmiChains.push(wagmiChain);
+        }
+        finalConfig.transports[wagmiChain.id] = chain.wsTarget ? viem.webSocket(chain.wsTarget) : viem.http(chain.rpcTarget);
+      });
+      finalConfig.chains = [wagmiChains[0], ...wagmiChains.slice(1)];
+    }
+    if (!finalConfig.chains) return;
+    return wagmi.createConfig(finalConfig);
+  }, [config, web3Auth, isInitialized]);
+  return react.createElement(wagmi.WagmiProvider, // typecast to WagmiProviderPropsBase to avoid type error
+  // as we are omitting the config prop from WagmiProviderProps
+  // and creating a new config object with the finalConfig
+  _objectSpread(_objectSpread({}, props), {}, {
+    config: finalConfig,
+    reconnectOnMount: false
+  }), react.createElement(Web3AuthWagmiProvider, null, children));
+}
+
+exports.WagmiProvider = WagmiProvider;