@openfort/react 1.0.1 → 1.0.2

package/build/components/Openfort/OpenfortProvider.js

@@ -9,12 +9,14 @@ import { CoreOpenfortProvider } from '../../openfort/CoreOpenfortProvider.js';
 import { logger } from '../../utils/logger.js';
 import { buildChainFromConfig } from '../../utils/rpc.js';
 import { isFamily } from '../../utils/wallets.js';
-import { EmbeddedWalletWagmiSync } from '../../wagmi/useEmbeddedWalletWagmiSync.js';
 import { OpenfortContext, UIContext } from './context.js';
 import { UIAuthProvider, routes, defaultSendFormState, defaultBuyFormState, notStoredInHistoryRoutes } from './types.js';
 
-const SolanaContextProvider = lazy(() => import('../../solana/SolanaContext.js').then((m) => ({ default: m.SolanaContextProvider })));
-const LazyConnectKitModal = lazy(() => import('../ConnectModal/index.js'));
+const SolanaContextProvider = lazy(() => import(/* @vite-ignore */ '../../solana/SolanaContext.js').then((m) => ({ default: m.SolanaContextProvider })));
+const LazyEmbeddedWalletWagmiSync = lazy(() => import(/* @vite-ignore */ '../../wagmi/useEmbeddedWalletWagmiSync.js').then((m) => ({
+    default: m.EmbeddedWalletWagmiSync,
+})));
+const LazyConnectKitModal = lazy(() => import(/* @vite-ignore */ '../ConnectModal/index.js'));
 let openfortProviderWarnedNoWagmi = false;
 /**
  * Root provider for Openfort. Wrap your app with this to enable connect modal, auth, and wallet features.
@@ -92,8 +94,8 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
             defaultMethod: allowAutomaticRecovery ? RecoveryMethod.AUTOMATIC : RecoveryMethod.PASSWORD,
         },
         authProviders: hasWagmi
-            ? [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.WALLET]
-            : [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP],
+            ? [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.WALLET, UIAuthProvider.GOOGLE]
+            : [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.GOOGLE],
     }), [allowAutomaticRecovery, hasWagmi]);
     const safeUiConfig = useMemo(() => {
         var _a, _b, _c, _d, _e;
@@ -318,7 +320,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
         setBuyForm,
         triggerResize,
     ]);
-    const innerChildren = (jsxs(Fragment, { children: [hasWagmi && jsx(EmbeddedWalletWagmiSync, {}), debugModeOptions.debugRoutes && (jsx("pre", { style: {
+    const innerChildren = (jsxs(Fragment, { children: [hasWagmi && (jsx(Suspense, { fallback: null, children: jsx(LazyEmbeddedWalletWagmiSync, {}) })), debugModeOptions.debugRoutes && (jsx("pre", { style: {
                     position: 'absolute',
                     top: 0,
                     left: 0,

package/build/components/Openfort/OpenfortProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"OpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"OpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/CreateWallet/index.js

@@ -1,7 +1,7 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
 import { motion } from 'framer-motion';
-import { useEffect, useState, useCallback, useMemo } from 'react';
+import { useEffect, useState, useRef, useCallback, useMemo } from 'react';
 import { PlusIcon, PhoneIcon, EmailIcon, FingerPrintIcon, KeyIcon, ShieldIcon, LockIcon } from '../../../assets/icons.js';
 import Logos from '../../../assets/logos.js';
 import { OpenfortError } from '../../../types.js';
@@ -64,15 +64,17 @@ const OtherMethod = ({ currentMethod, onChangeMethod, }) => {
 const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
     var _a;
     const { embeddedState } = useOpenfortCore();
-    const { setRoute, triggerResize } = useOpenfort();
+    const { setRoute, triggerResize, walletConfig } = useOpenfort();
     const [recoveryError, setRecoveryError] = useState(null);
     const { create } = useEthereumEmbeddedWallet();
     const { isEnabled: isWalletRecoveryOTPEnabled, requestOTP } = useRecoveryOTP();
     const [shouldCreateWallet, setShouldCreateWallet] = useState(false);
+    const isCreatingRef = useRef(false);
     const [needsOTP, setNeedsOTP] = useState(false);
     const [otpResponse, setOtpResponse] = useState(null);
     const [otpStatus, setOtpStatus] = useState('idle');
     const [error, setError] = useState(false);
+    const [canSendOtp, setCanSendOtp] = useState(true);
     const handleCompleteOtp = async (otp) => {
         setOtpStatus('loading');
         try {
@@ -96,13 +98,18 @@ const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
     useEffect(() => {
         if (!shouldCreateWallet)
             return;
+        if (isCreatingRef.current)
+            return;
+        isCreatingRef.current = true;
         (async () => {
             logger.log('Creating wallet Automatic recover');
             try {
                 await create({ recoveryMethod: RecoveryMethod.AUTOMATIC });
+                setShouldCreateWallet(false);
                 setRoute(routes.CONNECTED_SUCCESS);
             }
             catch (err) {
+                setShouldCreateWallet(false);
                 const { error, isOTPRequired } = handleOtpRecoveryError(err, isWalletRecoveryOTPEnabled);
                 if (isOTPRequired && isWalletRecoveryOTPEnabled) {
                     try {
@@ -120,15 +127,19 @@ const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
                     setRecoveryError(error);
                 }
             }
+            finally {
+                isCreatingRef.current = false;
+            }
             triggerResize();
         })();
     }, [shouldCreateWallet, create, isWalletRecoveryOTPEnabled, requestOTP, triggerResize]);
-    const [canSendOtp, setCanSendOtp] = useState(true);
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreateWallet(true);
-        }
-    }, [embeddedState]);
+        if (embeddedState !== EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED)
+            return;
+        if ((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) === false)
+            return;
+        setShouldCreateWallet(true);
+    }, [embeddedState, walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin]);
     const handleResendClick = useCallback(() => {
         setOtpStatus('send-otp');
         setCanSendOtp(false);
@@ -152,18 +163,23 @@ const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
     return (jsx(PageContent, { onBack: onBack, logoutOnBack: logoutOnBack, children: jsx(Loader, { isError: !!recoveryError, header: recoveryError ? 'Error creating wallet.' : `Creating wallet...`, description: recoveryError ? recoveryError.message : undefined }) }));
 };
 const CreateWalletPasskeyRecovery = ({ onChangeMethod, onBack, logoutOnBack, }) => {
-    const { triggerResize, setRoute } = useOpenfort();
+    const { triggerResize, setRoute, walletConfig } = useOpenfort();
     const { create } = useEthereumEmbeddedWallet();
     const [shouldCreateWallet, setShouldCreateWallet] = useState(false);
+    const isCreatingRef = useRef(false);
     const [recoveryError, setRecoveryError] = useState(null);
     const { embeddedState } = useOpenfortCore();
     useEffect(() => {
         if (!shouldCreateWallet)
             return;
+        if (isCreatingRef.current)
+            return;
+        isCreatingRef.current = true;
         (async () => {
             logger.log('Creating wallet passkey recovery');
             try {
                 await create({ recoveryMethod: RecoveryMethod.PASSKEY });
+                setShouldCreateWallet(false);
                 setRoute(routes.CONNECTED_SUCCESS);
             }
             catch (err) {
@@ -171,13 +187,18 @@ const CreateWalletPasskeyRecovery = ({ onChangeMethod, onBack, logoutOnBack, })
                 setRecoveryError(new Error('Failed to create wallet'));
                 setShouldCreateWallet(false);
             }
+            finally {
+                isCreatingRef.current = false;
+            }
         })();
     }, [shouldCreateWallet, create]);
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreateWallet(true);
-        }
-    }, [embeddedState]);
+        if (embeddedState !== EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED)
+            return;
+        if ((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) === false)
+            return;
+        setShouldCreateWallet(true);
+    }, [embeddedState, walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin]);
     useEffect(() => {
         if (recoveryError)
             triggerResize();
@@ -269,8 +290,7 @@ const CreateOrConnectWallet = () => {
 };
 const EthereumCreateWallet = () => {
     const { uiConfig, walletConfig, setRoute } = useOpenfort();
-    const { user } = useOpenfortCore();
-    const { chainType } = useOpenfortCore();
+    const { user, chainType } = useOpenfortCore();
     // Use chain-specific hooks
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();

package/build/components/Pages/CreateWallet/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/LoadWallets/index.js

@@ -29,9 +29,8 @@ const errorForChainRegistry = {
     }),
 };
 const LoadWallets = () => {
-    const { chainType } = useOpenfortCore();
-    const { user } = useOpenfortCore();
-    const { triggerResize, setRoute, setConnector } = useOpenfort();
+    const { chainType, user } = useOpenfortCore();
+    const { triggerResize, setRoute, setConnector, walletConfig } = useOpenfort();
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
     const embeddedWallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
@@ -62,6 +61,10 @@ const LoadWallets = () => {
         }
         logger.log('User wallets loaded:', wallets.length);
         if (wallets.length === 0) {
+            if ((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) === false) {
+                setRoute(routes.CONNECTED);
+                return;
+            }
             setRoute(createRoute(chainType));
             return;
         }
@@ -80,7 +83,7 @@ const LoadWallets = () => {
             return;
         }
         setRoute(routes.SELECT_WALLET_TO_RECOVER);
-    }, [loadingUX, isLoadingWallets, wallets, user, chainType, setRoute, setConnector]);
+    }, [loadingUX, isLoadingWallets, wallets, user, chainType, setRoute, setConnector, walletConfig]);
     const { isError: isErrorFromChain, message: errorMessageFromChain } = errorForChainRegistry[chainType](errorWallets);
     const isError = !user || isErrorFromChain;
     const errorMessage = !user ? undefined : errorMessageFromChain;

package/build/components/Pages/LoadWallets/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/constants/openfort.d.ts

@@ -1,5 +1,8 @@
+import { AccountTypeEnum } from '@openfort/openfort-js';
 /**
  * Identifier for the Openfort embedded wallet connector.
  * Used when identifying the embedded wallet in connector lists.
  */
 export declare const embeddedWalletId = "xyz.openfort";
+/** Default account type when none is specified in walletConfig or create options. */
+export declare const DEFAULT_ACCOUNT_TYPE = AccountTypeEnum.EOA;

package/build/constants/openfort.js

@@ -1,8 +1,12 @@
+import { AccountTypeEnum } from '@openfort/openfort-js';
+
 /**
  * Identifier for the Openfort embedded wallet connector.
  * Used when identifying the embedded wallet in connector lists.
  */
 const embeddedWalletId = 'xyz.openfort';
+/** Default account type when none is specified in walletConfig or create options. */
+const DEFAULT_ACCOUNT_TYPE = AccountTypeEnum.EOA;
 
-export { embeddedWalletId };
+export { DEFAULT_ACCOUNT_TYPE, embeddedWalletId };
 //# sourceMappingURL=openfort.js.map

package/build/constants/openfort.js.map

@@ -1 +1 @@
-{"version":3,"file":"openfort.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}
+{"version":3,"file":"openfort.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/build/ethereum/hooks/useEthereumEmbeddedWallet.js

@@ -1,7 +1,8 @@
-import { ChainTypeEnum, AccountTypeEnum, EmbeddedState, RecoveryMethod } from '@openfort/openfort-js';
+import { ChainTypeEnum, EmbeddedState, RecoveryMethod } from '@openfort/openfort-js';
 import { useRef, useState, useMemo, useCallback, useEffect } from 'react';
 import { baseSepolia } from 'viem/chains';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { DEFAULT_ACCOUNT_TYPE } from '../../constants/openfort.js';
 import { useConnectionStrategy } from '../../core/ConnectionStrategyContext.js';
 import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
 import { useOpenfortCore } from '../../openfort/useOpenfort.js';
@@ -131,11 +132,11 @@ function useEthereumEmbeddedWallet(options) {
                 },
             });
             // Determine account type (use createOptions, then walletConfig, else default to Smart Account)
-            const accountType = (_c = (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.accountType) !== null && _a !== void 0 ? _a : (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : AccountTypeEnum.SMART_ACCOUNT;
+            const accountType = (_c = (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.accountType) !== null && _a !== void 0 ? _a : (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : DEFAULT_ACCOUNT_TYPE;
             const account = await client.embeddedWallet.create({
                 chainType: ChainTypeEnum.EVM,
                 accountType,
-                ...(accountType !== AccountTypeEnum.EOA && { chainId: (_d = createOptions === null || createOptions === void 0 ? void 0 : createOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
+                ...(accountType !== DEFAULT_ACCOUNT_TYPE && { chainId: (_d = createOptions === null || createOptions === void 0 ? void 0 : createOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
                 recoveryParams,
             });
             await updateEmbeddedAccounts({ silent: true });

package/build/ethereum/hooks/useEthereumEmbeddedWallet.js.map

@@ -1 +1 @@
-{"version":3,"file":"useEthereumEmbeddedWallet.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useEthereumEmbeddedWallet.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.js

@@ -1,6 +1,7 @@
-import { AccountTypeEnum, ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
+import { ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
 import { useCallback } from 'react';
 import { useOpenfort } from '../../../components/Openfort/useOpenfort.js';
+import { DEFAULT_ACCOUNT_TYPE } from '../../../constants/openfort.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { buildRecoveryParams } from '../../../shared/utils/recovery.js';
 import { logger } from '../../../utils/logger.js';
@@ -54,11 +55,11 @@ const useConnectToWalletPostAuth = () => {
                     getAccessToken: () => client.getAccessToken(),
                     getUserId: async () => { var _a; return (_a = (await client.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
                 });
-                const accountType = (_c = (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : AccountTypeEnum.SMART_ACCOUNT;
+                const accountType = (_c = (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : DEFAULT_ACCOUNT_TYPE;
                 const account = await client.embeddedWallet.create({
                     chainType,
-                    accountType: chainType === ChainTypeEnum.EVM ? accountType : AccountTypeEnum.EOA,
-                    ...(chainType === ChainTypeEnum.EVM && accountType !== AccountTypeEnum.EOA && { chainId }),
+                    accountType: chainType === ChainTypeEnum.EVM ? accountType : DEFAULT_ACCOUNT_TYPE,
+                    ...(chainType === ChainTypeEnum.EVM && accountType !== DEFAULT_ACCOUNT_TYPE && { chainId }),
                     recoveryParams,
                 });
                 await updateEmbeddedAccounts({ silent: true });

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.js.map

@@ -1 +1 @@
-{"version":3,"file":"useConnectToWalletPostAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useConnectToWalletPostAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.0.1";
+export declare const OPENFORT_VERSION = "1.0.2";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.0.1';
+const OPENFORT_VERSION = '1.0.2';
 
 export { OPENFORT_VERSION };
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",