@openfort/react 1.0.2 → 1.0.3

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

@@ -1,10 +1,9 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
+import { RecoveryMethod } from '@openfort/openfort-js';
 import { motion } from 'framer-motion';
 import { useState, useEffect, useCallback, useMemo } from 'react';
 import { PhoneIcon, EmailIcon, FingerPrintIcon, KeyIcon, LockIcon } from '../../../assets/icons.js';
 import { OpenfortError } from '../../../types.js';
-import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { useRecoveryOTP } from '../../../shared/hooks/useRecoveryOTP.js';
 import { handleOtpRecoveryError } from '../../../shared/utils/otpError.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
@@ -55,7 +54,6 @@ const OtherMethod = ({ currentMethod, onChangeMethod, }) => {
 };
 const SolanaCreateAutomatic = ({ onBack, logoutOnBack }) => {
     var _a;
-    const { embeddedState } = useOpenfortCore();
     const { setRoute, triggerResize } = useOpenfort();
     const embeddedWallet = useSolanaEmbeddedWallet();
     const { isEnabled: isWalletRecoveryOTPEnabled, requestOTP } = useRecoveryOTP();
@@ -115,11 +113,12 @@ const SolanaCreateAutomatic = ({ onBack, logoutOnBack }) => {
         })();
     }, [shouldCreate]);
     const [canSendOtp, setCanSendOtp] = useState(true);
+    // Trigger creation on mount. We only land here when no Solana wallet exists.
+    // Don't gate on embeddedState — the user may have an EVM wallet (embeddedState=READY)
+    // but still need a Solana wallet.
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreate(true);
-        }
-    }, [embeddedState]);
+        setShouldCreate(true);
+    }, []);
     const handleResendClick = useCallback(() => {
         setOtpStatus('send-otp');
         setCanSendOtp(false);
@@ -145,7 +144,6 @@ const SolanaCreateAutomatic = ({ onBack, logoutOnBack }) => {
 const SolanaCreatePasskey = ({ onChangeMethod, onBack, logoutOnBack, }) => {
     const { triggerResize, setRoute } = useOpenfort();
     const embeddedWallet = useSolanaEmbeddedWallet();
-    const { embeddedState } = useOpenfortCore();
     const [shouldCreate, setShouldCreate] = useState(false);
     const [recoveryError, setRecoveryError] = useState(null);
     useEffect(() => {
@@ -164,11 +162,12 @@ const SolanaCreatePasskey = ({ onChangeMethod, onBack, logoutOnBack, }) => {
             }
         })();
     }, [shouldCreate]);
+    // Trigger creation on mount. We only land here when no Solana wallet exists.
+    // Don't gate on embeddedState — the user may have an EVM wallet (embeddedState=READY)
+    // but still need a Solana wallet.
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreate(true);
-        }
-    }, [embeddedState]);
+        setShouldCreate(true);
+    }, []);
     useEffect(() => {
         if (recoveryError)
             triggerResize();

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

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

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

@@ -29,7 +29,7 @@ const errorForChainRegistry = {
     }),
 };
 const LoadWallets = () => {
-    const { chainType, user } = useOpenfortCore();
+    const { chainType, user, isLoadingAccounts } = useOpenfortCore();
     const { triggerResize, setRoute, setConnector, walletConfig } = useOpenfort();
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
@@ -38,7 +38,10 @@ const LoadWallets = () => {
     const wallets = embeddedWallet.wallets;
     const isLoadingWallets = embeddedWallet.status === 'fetching-wallets' ||
         embeddedWallet.status === 'connecting' ||
-        embeddedWallet.status === 'creating';
+        embeddedWallet.status === 'creating' ||
+        // For Solana, the hook never enters 'fetching-wallets' — accounts are derived from the
+        // core embeddedAccounts store. Wait for the core fetch to complete before routing.
+        isLoadingAccounts;
     const errorWallets = embeddedWallet.status === 'error' ? new Error(embeddedWallet.error) : undefined;
     useEffect(() => {
         let timeout;

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/hooks/openfort/useUser.d.ts

@@ -6,7 +6,7 @@
  *
  * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
  *
- * @returns user, linkedAccounts, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
+ * @returns user, linkedAccounts, isLoading, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
  *
  * @example
  * ```tsx
@@ -21,6 +21,7 @@
 export declare function useUser(): {
     user: import("@openfort/openfort-js").User | null;
     linkedAccounts: import("@openfort/openfort-js").UserAccount[];
+    isLoading: boolean;
     isAuthenticated: boolean;
     isConnected: boolean;
     getAccessToken: () => Promise<string | null>;

package/build/hooks/openfort/useUser.js

@@ -11,7 +11,7 @@ import { handleOAuthConfigError } from '../../utils/oauthErrorHandler.js';
  *
  * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
  *
- * @returns user, linkedAccounts, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
+ * @returns user, linkedAccounts, isLoading, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
  *
  * @example
  * ```tsx
@@ -24,7 +24,7 @@ import { handleOAuthConfigError } from '../../utils/oauthErrorHandler.js';
  * ```
  */
 function useUser() {
-    const { user, client, embeddedState, linkedAccounts, activeEmbeddedAddress } = useOpenfortCore();
+    const { user, client, embeddedState, linkedAccounts, activeEmbeddedAddress, isLoading } = useOpenfortCore();
     const isAuthenticated = embeddedState !== EmbeddedState.NONE && embeddedState !== EmbeddedState.UNAUTHENTICATED;
     const isConnected = embeddedState === EmbeddedState.READY && !!activeEmbeddedAddress;
     const getAccessTokenAndUpdate = useCallback(async () => {
@@ -50,6 +50,7 @@ function useUser() {
     return {
         user,
         linkedAccounts,
+        isLoading,
         isAuthenticated,
         isConnected,
         getAccessToken: getAccessTokenAndUpdate,

package/build/hooks/openfort/useUser.js.map

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

package/build/openfort/CoreOpenfortProvider.js

@@ -1,5 +1,5 @@
 import { ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
-import { useContext, useMemo, useState, useEffect, useRef, useCallback, useLayoutEffect, createElement, Fragment } from 'react';
+import { useContext, useMemo, useState, useEffect, useRef, useLayoutEffect, useCallback, createElement, Fragment } from 'react';
 import { useStore } from 'zustand';
 import { routes } from '../components/Openfort/types.js';
 import { useOpenfort } from '../components/Openfort/useOpenfort.js';
@@ -99,8 +99,10 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
             });
         });
     }, []);
-    // Sync chainType from UI context into the store
-    useEffect(() => {
+    // Sync chainType from UI context into the store — useLayoutEffect so the store
+    // is updated before the next paint, preventing a one-render-cycle race where
+    // the strategy context (synchronous) sees SVM but the store still shows EVM.
+    useLayoutEffect(() => {
         store.getState().setChainType(chainType);
     }, [store, chainType]);
     // Recompute isLoading when bridge address changes (bridge connects/disconnects)

package/build/openfort/CoreOpenfortProvider.js.map

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

package/build/version.d.ts

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

package/build/version.js

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

package/build/wagmi/embeddedConnector.js

@@ -9,7 +9,12 @@ function setEmbeddedWalletProvider(p) {
 function embeddedWalletConnector() {
     return createConnector((config) => {
         const accountsChangedHandler = (accs) => {
-            config.emitter.emit('change', { accounts: accs });
+            // Filter out non-EVM addresses (e.g. Solana base58) that the SDK may emit
+            // when recover() is called for a Solana wallet — sdk bug, defensive guard.
+            const valid = accs.filter((a) => /^0x[0-9a-fA-F]{40}$/i.test(a));
+            if (valid.length === 0)
+                return;
+            config.emitter.emit('change', { accounts: valid });
         };
         const chainChangedHandler = (chain) => {
             config.emitter.emit('change', { chainId: Number(chain) });

package/build/wagmi/embeddedConnector.js.map

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

package/package.json

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