@openfort/react 1.0.0 → 1.0.2

package/build/assets/icons.js

@@ -1,4 +1,4 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
+import { jsxs, jsx } from 'react/jsx-runtime';
 
 const SendIcon = ({ ...props }) => (jsxs("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props, children: [jsx("path", { d: "M5 19L19 5", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M9 5H19V15", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));
 const ReceiveIcon = ({ ...props }) => (jsxs("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props, children: [jsx("path", { d: "M19 5L5 19", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M15 19H5V9", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));

package/build/components/ConnectModal/index.js

@@ -44,11 +44,8 @@ import RemoveLinkedProvider from '../Pages/RemoveLinkedProvider/index.js';
 import SelectToken from '../Pages/SelectToken/index.js';
 import SelectWalletToRecover from '../Pages/SelectWalletToRecover/index.js';
 import Send from '../Pages/Send/index.js';
-import { SolanaSend } from '../Pages/Send/SolanaSend.js';
 import SendConfirmation from '../Pages/SendConfirmation/index.js';
 import SocialProviders from '../Pages/SocialProviders/index.js';
-import SolanaSendConfirmation from '../Pages/SolanaSendConfirmation/index.js';
-import SolanaWallets from '../Pages/SolanaWallets/index.js';
 import ConnectUsing from './ConnectUsing.js';
 import ConnectWithMobile from './ConnectWithMobile.js';
 
@@ -112,10 +109,10 @@ const CHAIN_PREFIXED_PAGES = {
         'sol:connected': jsx(Connected, {}),
         'sol:createWallet': jsx(CreateWallet, {}),
         'sol:recoverWallet': jsx(RecoverPage, {}),
-        'sol:send': jsx(SolanaSend, {}),
-        'sol:sendConfirmation': jsx(SolanaSendConfirmation, {}),
+        // 'sol:send': <SolanaSend />,
+        // 'sol:sendConfirmation': <SolanaSendConfirmation />,
         'sol:receive': jsx(Receive, {}),
-        'sol:wallets': jsx(SolanaWallets, {}),
+        // 'sol:wallets': <SolanaWallets />,
     },
 };
 const DEFAULT_CONNECTED_ROUTE = {

package/build/components/ConnectModal/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/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/components/Pages/Send/index.js

@@ -2,11 +2,10 @@ import { jsx } from 'react/jsx-runtime';
 import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { EthereumSend } from './EthereumSend.js';
-import { SolanaSend } from './SolanaSend.js';
 
 const SEND_REGISTRY = {
     [ChainTypeEnum.EVM]: EthereumSend,
-    [ChainTypeEnum.SVM]: SolanaSend,
+    // [ChainTypeEnum.SVM]: SolanaSend,
 };
 const Send = () => {
     const { chainType } = useOpenfortCore();

package/build/components/Pages/Send/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/solana/hooks/utils.d.ts

@@ -1,2 +1 @@
-export declare function solToLamports(sol: number): bigint;
 export declare function formatSol(lamports: bigint, decimals?: number): string;

package/build/solana/hooks/utils.js

@@ -1,12 +1,4 @@
-import { LAMPORTS_PER_SOL } from '../constants.js';
-
-function solToLamports(sol) {
-    // Use toFixed(9) to avoid scientific notation (e.g. 1e-9) for small values
-    const str = sol.toFixed(9);
-    const [whole = '0', frac = ''] = str.split('.');
-    const padded = frac.slice(0, 9);
-    return BigInt(whole) * LAMPORTS_PER_SOL + BigInt(padded);
-}
+const LAMPORTS_PER_SOL = BigInt(1000000000);
 function formatSol(lamports, decimals = 4) {
     const whole = lamports / LAMPORTS_PER_SOL;
     const remainder = lamports % LAMPORTS_PER_SOL;
@@ -14,5 +6,5 @@ function formatSol(lamports, decimals = 4) {
     return `${whole}.${fracStr}`.replace(new RegExp(`(\\d*\\.\\d{${decimals}})\\d*`), '$1');
 }
 
-export { formatSol, solToLamports };
+export { formatSol };
 //# sourceMappingURL=utils.js.map

package/build/solana/hooks/utils.js.map

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

package/build/version.d.ts

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

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.0.0';
+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.0",
+  "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.",

package/build/components/Pages/Send/SolanaSend.d.ts

@@ -1 +0,0 @@
-export declare function SolanaSend(): import("react/jsx-runtime").JSX.Element;

package/build/components/Pages/Send/SolanaSend.js

@@ -1,93 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useCallback } from 'react';
-import { fetchSolanaBalance } from '../../../hooks/useBalance.js';
-import { useAsyncData } from '../../../shared/hooks/useAsyncData.js';
-import { isValidSolanaAddress } from '../../../shared/utils/validation.js';
-import { BASE_FEE_LAMPORTS, RENT_EXEMPT_MINIMUM_LAMPORTS } from '../../../solana/constants.js';
-import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
-import { solToLamports, formatSol } from '../../../solana/hooks/utils.js';
-import { useSolanaContext } from '../../../solana/SolanaContext.js';
-import { logger } from '../../../utils/logger.js';
-import Button from '../../Common/Button/index.js';
-import Input from '../../Common/Input/index.js';
-import { ModalHeading } from '../../Common/Modal/styles.js';
-import { routes } from '../../Openfort/types.js';
-import { useOpenfort } from '../../Openfort/useOpenfort.js';
-import { PageContent } from '../../PageContent/index.js';
-import { Form, Field, FieldLabel, AmountInputWrapper, MaxButton, HelperText, ErrorText } from './styles.js';
-import { sanitizeForParsing, sanitizeAmountInput } from './utils.js';
-
-const RENT_EXEMPT_LAMPORTS = RENT_EXEMPT_MINIMUM_LAMPORTS;
-function SolanaSend() {
-    var _a, _b, _c;
-    const { rpcUrl } = useSolanaContext();
-    const { sendForm, setSendForm, setRoute } = useOpenfort();
-    const wallet = useSolanaEmbeddedWallet();
-    const recipient = sendForm.recipient;
-    const amount = sendForm.amount;
-    const walletAddress = wallet.status === 'connected' ? (_a = wallet.activeWallet) === null || _a === void 0 ? void 0 : _a.address : undefined;
-    const provider = wallet.status === 'connected' ? wallet.provider : null;
-    const balanceResult = useAsyncData({
-        queryKey: ['solana-balance', walletAddress, rpcUrl],
-        queryFn: async () => {
-            if (!walletAddress || !rpcUrl)
-                return null;
-            try {
-                const result = await fetchSolanaBalance(walletAddress, rpcUrl, 'confirmed');
-                return { value: result.value };
-            }
-            catch (error) {
-                logger.error('Failed to fetch Solana balance:', error);
-                return null;
-            }
-        },
-        enabled: Boolean(walletAddress && rpcUrl),
-    });
-    const balanceLamports = (_c = (_b = balanceResult.data) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : BigInt(0);
-    const recipientValid = recipient.length > 0 && isValidSolanaAddress(recipient);
-    const amountNum = amount === '' || amount === '.' ? null : parseFloat(amount);
-    const amountLamports = amountNum !== null && !Number.isNaN(amountNum) && amountNum > 0 ? solToLamports(amountNum) : null;
-    const insufficientBalance = amountLamports !== null && balanceLamports !== undefined ? amountLamports > balanceLamports : false;
-    const belowRentExempt = amountLamports !== null && balanceLamports !== undefined
-        ? balanceLamports - amountLamports < RENT_EXEMPT_LAMPORTS
-        : false;
-    const hasAmount = amountLamports !== null && amountLamports > BigInt(0);
-    const amountValid = hasAmount && !insufficientBalance && !belowRentExempt;
-    const maxLamports = balanceLamports > BASE_FEE_LAMPORTS ? balanceLamports - BASE_FEE_LAMPORTS - RENT_EXEMPT_LAMPORTS : BigInt(0);
-    const maxLamportsSafe = maxLamports > BigInt(0) ? maxLamports : BigInt(0);
-    const canProceed = recipientValid && amountValid && !!provider;
-    const handleMax = useCallback(() => {
-        if (maxLamportsSafe <= BigInt(0))
-            return;
-        setSendForm((prev) => ({ ...prev, amount: formatSol(maxLamportsSafe, 9) }));
-    }, [maxLamportsSafe, setSendForm]);
-    const handleSubmit = (event) => {
-        event.preventDefault();
-        if (!canProceed || !amountLamports || amountLamports <= BigInt(0))
-            return;
-        const normalized = sanitizeForParsing(amount);
-        if (!normalized)
-            return;
-        setSendForm((prev) => ({
-            ...prev,
-            amount: normalized,
-            recipient,
-            asset: prev.asset,
-        }));
-        setRoute(routes.SOL_SEND_CONFIRMATION);
-    };
-    const handleRecipientChange = (e) => {
-        setSendForm((prev) => ({ ...prev, recipient: e.target.value }));
-    };
-    const handleAmountChange = (e) => {
-        const raw = sanitizeAmountInput(e.target.value);
-        if (raw === '' || /^[0-9]*\.?[0-9]*$/.test(raw)) {
-            setSendForm((prev) => ({ ...prev, amount: raw }));
-        }
-    };
-    const availableLabel = balanceResult.data != null ? formatSol(balanceLamports) : '--';
-    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Send SOL" }), jsxs(Form, { onSubmit: handleSubmit, children: [jsxs(Field, { children: [jsx(FieldLabel, { children: "Amount" }), jsxs(AmountInputWrapper, { children: [jsx(Input, { placeholder: "0.00", value: amount, onChange: handleAmountChange, inputMode: "decimal", autoComplete: "off", style: { paddingRight: '86px' } }), jsx(MaxButton, { type: "button", onClick: handleMax, disabled: maxLamportsSafe <= BigInt(0), children: "Max" })] }), jsxs(HelperText, { children: ["Available: ", availableLabel, " SOL"] }), amount && amountNum !== null && Number.isNaN(amountNum) && jsx(ErrorText, { children: "Enter a valid amount." }), insufficientBalance && jsx(ErrorText, { children: "Insufficient balance for this transfer." }), belowRentExempt && jsx(ErrorText, { children: "Leave enough for rent-exempt minimum (~0.00089 SOL)." })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Recipient address" }), jsx(Input, { placeholder: "Base58 address...", value: recipient, onChange: handleRecipientChange, autoComplete: "off" }), recipient && !recipientValid && jsx(ErrorText, { children: "Enter a valid Solana address." })] }), jsx(Button, { variant: "primary", disabled: !canProceed, type: "submit", children: "Review transfer" })] })] }));
-}
-
-export { SolanaSend };
-//# sourceMappingURL=SolanaSend.js.map

package/build/components/Pages/Send/SolanaSend.js.map

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

package/build/components/Pages/SolanaSendConfirmation/index.d.ts

@@ -1 +0,0 @@
-export default function SolanaSendConfirmation(): import("react/jsx-runtime").JSX.Element;

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

@@ -1,152 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { ChainTypeEnum } from '@openfort/openfort-js';
-import { createSolanaRpc, address, pipe, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction, compileTransaction, getBase64EncodedWireTransaction, getBase58Encoder } from '@solana/kit';
-import { useState, useRef, useCallback, useEffect } from 'react';
-import { TickIcon } from '../../../assets/icons.js';
-import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
-import { invalidateBalance } from '../../../hooks/useBalance.js';
-import { getExplorerUrl } from '../../../shared/utils/explorer.js';
-import { BASE_FEE_LAMPORTS } from '../../../solana/constants.js';
-import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
-import { solToLamports, formatSol } from '../../../solana/hooks/utils.js';
-import { useSolanaContext } from '../../../solana/SolanaContext.js';
-import { createTransferSolInstruction } from '../../../solana/utils/transfer.js';
-import 'detect-browser';
-import { truncateSolanaAddress } from '../../../utils/format.js';
-import Button from '../../Common/Button/index.js';
-import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
-import Loader from '../../Common/Loading/index.js';
-import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
-import { routes } from '../../Openfort/types.js';
-import { useOpenfort } from '../../Openfort/useOpenfort.js';
-import { PageContent } from '../../PageContent/index.js';
-import { sanitizeForParsing } from '../Send/utils.js';
-import { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, FeesValue, CheckIconWrapper, ErrorContainer, ErrorTitle, ErrorMessage } from '../SendConfirmation/styles.js';
-
-const CONFIRM_POLL_MS = 500;
-const CONFIRM_TIMEOUT_MS = 60000;
-async function waitForConfirmation(rpcUrl, signature) {
-    var _a, _b;
-    const deadline = Date.now() + CONFIRM_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        const res = await fetch(rpcUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'getSignatureStatuses',
-                params: [[signature], { searchTransactionHistory: true }],
-            }),
-        });
-        const data = await res.json();
-        const status = (_b = (_a = data.result) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b[0];
-        if (status === null || status === void 0 ? void 0 : status.err)
-            throw new Error(typeof status.err === 'object' ? JSON.stringify(status.err) : String(status.err));
-        if ((status === null || status === void 0 ? void 0 : status.confirmationStatus) === 'confirmed' || (status === null || status === void 0 ? void 0 : status.confirmationStatus) === 'finalized')
-            return;
-        await new Promise((r) => setTimeout(r, CONFIRM_POLL_MS));
-    }
-    throw new OpenfortError('Transaction confirmation timed out', OpenfortReactErrorType.UNEXPECTED_ERROR);
-}
-const ED25519_SIGNATURE_LENGTH = 64;
-function decodeSignatureToBytes(signature) {
-    const encoded = getBase58Encoder().encode(signature);
-    let bytes = new Uint8Array(encoded);
-    if (bytes.length === ED25519_SIGNATURE_LENGTH + 1) {
-        bytes = bytes.slice(0, ED25519_SIGNATURE_LENGTH);
-    }
-    if (bytes.length === ED25519_SIGNATURE_LENGTH)
-        return bytes;
-    throw new OpenfortError(`Invalid signature: expected ${ED25519_SIGNATURE_LENGTH} bytes, got ${bytes.length}.`, OpenfortReactErrorType.CONFIGURATION_ERROR);
-}
-function SolanaSendConfirmation() {
-    var _a;
-    const { rpcUrl, cluster } = useSolanaContext();
-    const { sendForm, setRoute, triggerResize } = useOpenfort();
-    const wallet = useSolanaEmbeddedWallet();
-    const walletAddress = wallet.status === 'connected' ? (_a = wallet.activeWallet) === null || _a === void 0 ? void 0 : _a.address : undefined;
-    const provider = wallet.status === 'connected' ? wallet.provider : null;
-    const [txStatus, setTxStatus] = useState('idle');
-    const [txSignature, setTxSignature] = useState(null);
-    const [errorMessage, setErrorMessage] = useState(null);
-    const confirmAbortRef = useRef(null);
-    const normalisedAmount = sanitizeForParsing(sendForm.amount);
-    const parsedAmount = normalisedAmount && !Number.isNaN(parseFloat(normalisedAmount)) && parseFloat(normalisedAmount) > 0
-        ? solToLamports(parseFloat(normalisedAmount))
-        : null;
-    const recipient = sendForm.recipient.trim();
-    const isSponsored = false;
-    const canProceed = !!provider &&
-        !!walletAddress &&
-        !!recipient &&
-        parsedAmount !== null &&
-        parsedAmount > BigInt(0) &&
-        txStatus === 'idle';
-    const handleConfirm = useCallback(async () => {
-        var _a;
-        if (!canProceed || !provider || !walletAddress || !parsedAmount || parsedAmount <= BigInt(0))
-            return;
-        setErrorMessage(null);
-        setTxStatus('signing');
-        try {
-            const rpc = createSolanaRpc(rpcUrl);
-            const { value: blockhash } = await rpc.getLatestBlockhash().send();
-            const fromAddress = address(walletAddress);
-            const transferInstruction = createTransferSolInstruction(walletAddress, recipient, parsedAmount);
-            const message = pipe(createTransactionMessage({ version: 0 }), (msg) => setTransactionMessageFeePayer(fromAddress, msg), (msg) => setTransactionMessageLifetimeUsingBlockhash(blockhash, msg), (msg) => appendTransactionMessageInstruction(transferInstruction, msg));
-            const compiled = compileTransaction(message);
-            const signed = await provider.signTransaction({ messageBytes: compiled.messageBytes });
-            const signatureBytes = decodeSignatureToBytes(signed.signature);
-            const signedTransaction = {
-                messageBytes: compiled.messageBytes,
-                signatures: { ...compiled.signatures, [fromAddress]: signatureBytes },
-            };
-            const encodedWire = getBase64EncodedWireTransaction(signedTransaction);
-            setTxStatus('sending');
-            await rpc
-                .sendTransaction(encodedWire, {
-                encoding: 'base64',
-                preflightCommitment: 'confirmed',
-                skipPreflight: false,
-            })
-                .send();
-            (_a = confirmAbortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
-            const confirmController = new AbortController();
-            confirmAbortRef.current = confirmController;
-            await waitForConfirmation(rpcUrl, signed.signature);
-            setTxSignature(signed.signature);
-            setTxStatus('confirmed');
-            invalidateBalance();
-        }
-        catch (err) {
-            if (err instanceof DOMException && err.name === 'AbortError')
-                return;
-            setTxStatus('error');
-            const msg = err instanceof OpenfortError ? err.message : err instanceof Error ? err.message : String(err);
-            setErrorMessage(msg || 'Transaction failed');
-        }
-    }, [canProceed, provider, walletAddress, parsedAmount, recipient, rpcUrl]);
-    useEffect(() => {
-        return () => {
-            var _a;
-            (_a = confirmAbortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
-        };
-    }, []);
-    useEffect(() => {
-        setTimeout(triggerResize, 10);
-    }, [txStatus, errorMessage, triggerResize]);
-    const feeDisplay = `~${formatSol(BASE_FEE_LAMPORTS, 6)} SOL`;
-    const explorerUrl = txSignature && cluster ? getExplorerUrl(ChainTypeEnum.SVM, { txHash: txSignature, cluster }) : undefined;
-    const handleOpenBlockExplorer = () => {
-        if (explorerUrl)
-            window.open(explorerUrl, '_blank', 'noopener,noreferrer');
-    };
-    if (txStatus === 'confirmed') {
-        return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(Loader, { isSuccess: true, header: "Transfer Sent", description: `${normalisedAmount || '0'} SOL sent successfully` }), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleOpenBlockExplorer, children: "View on Explorer" }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_CONNECTED), children: "Back to profile" })] })] }));
-    }
-    return (jsxs(PageContent, { onBack: routes.SOL_SEND, children: [jsx(ModalHeading, { children: "Confirm transfer" }), jsx(ModalBody, { children: "Review the transaction details before sending." }), jsxs(SummaryList, { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Sending" }), jsxs(AmountValue, { children: [normalisedAmount || '0', " SOL"] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: walletAddress ? (jsx(CopyText, { size: "1rem", value: walletAddress, children: truncateSolanaAddress(walletAddress) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipient ? (jsx(CopyText, { size: "1rem", value: recipient, children: truncateSolanaAddress(recipient) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Network fee" }), jsxs(FeesValue, { "$completed": isSponsored, children: [feeDisplay, jsx(CheckIconWrapper, { children: jsx(TickIcon, {}) })] })] }), isSponsored ] }), errorMessage && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: "Transaction failed" }), jsx(ErrorMessage, { children: errorMessage })] })), jsxs(ButtonRow, { children: [jsxs(Button, { variant: "primary", onClick: handleConfirm, disabled: !canProceed, waiting: txStatus === 'signing' || txStatus === 'sending', children: [txStatus === 'idle' && 'Confirm', txStatus === 'signing' && 'Signing...', txStatus === 'sending' && 'Sending...', txStatus === 'error' && 'Try again'] }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_SEND), disabled: txStatus !== 'idle', children: "Cancel" })] })] }));
-}
-
-export { SolanaSendConfirmation as default };
-//# sourceMappingURL=index.js.map

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

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

package/build/components/Pages/SolanaWallets/index.d.ts

@@ -1 +0,0 @@
-export default function SolanaWallets(): import("react/jsx-runtime").JSX.Element;

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

@@ -1,36 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { ChainTypeEnum } from '@openfort/openfort-js';
-import { PlusIcon } from '../../../assets/icons.js';
-import { toSolanaUserWallet } from '../../../hooks/openfort/walletTypes.js';
-import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
-import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
-import Button from '../../Common/Button/index.js';
-import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
-import { WalletRecoveryIcon } from '../../Common/WalletRecoveryIcon/index.js';
-import { recoverRoute } from '../../Openfort/routeHelpers.js';
-import { routes } from '../../Openfort/types.js';
-import { useOpenfort } from '../../Openfort/useOpenfort.js';
-import { PageContent } from '../../PageContent/index.js';
-import { ProvidersButton, ProviderIcon, ProviderLabel } from '../Providers/styles.js';
-
-function WalletRow({ wallet }) {
-    const { setRoute } = useOpenfort();
-    const { chainType } = useOpenfortCore();
-    const display = wallet.address.length > 12 ? `${wallet.address.slice(0, 4)}...${wallet.address.slice(-4)}` : wallet.address;
-    const handleClick = () => {
-        const walletForRoute = toSolanaUserWallet(wallet);
-        setRoute(recoverRoute(chainType, walletForRoute));
-    };
-    return (jsx(ProvidersButton, { children: jsxs(Button, { onClick: handleClick, children: [jsx(ProviderLabel, { children: display }), jsx(ProviderIcon, { children: jsx(WalletRecoveryIcon, { recovery: wallet.recoveryMethod }) })] }) }));
-}
-function SolanaWallets() {
-    var _a;
-    const { setRoute } = useOpenfort();
-    const embeddedWallet = useSolanaEmbeddedWallet();
-    const wallets = (_a = embeddedWallet.wallets) !== null && _a !== void 0 ? _a : [];
-    const solanaWallets = wallets.filter((w) => w.chainType === ChainTypeEnum.SVM);
-    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Solana Wallets" }), jsxs(ModalBody, { children: [solanaWallets.map((wallet) => (jsx(WalletRow, { wallet: wallet }, wallet.id))), jsx(ProvidersButton, { children: jsx(Button, { onClick: () => setRoute(routes.SOL_CREATE_WALLET), icon: jsx(ProviderIcon, { children: jsx(PlusIcon, {}) }), children: jsx(ProviderLabel, { children: "Create new wallet" }) }) })] })] }));
-}
-
-export { SolanaWallets as default };
-//# sourceMappingURL=index.js.map

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

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

package/build/shared/utils/validation.d.ts

@@ -1,15 +0,0 @@
-/**
- * Address validation utilities (dependency-free).
- *
- * openfort-js does not export address validation. The solana-sample example
- * (openfort-js/examples/apps/solana-sample) uses @solana/kit's address() in a
- * try/catch for Solana. We keep this shared util dependency-free so that
- * consumers that don't use @solana/kit (e.g. EVM-only apps) don't pull it in.
- * For stricter Solana validation when @solana/kit is available, use
- * address(addr) from '@solana/kit' in a try/catch. React-native package has no
- * shared address validation (no Send UI with recipient field in the repo).
- */
-/**
- * Validates a Solana address (Base58, 32–44 characters).
- */
-export declare function isValidSolanaAddress(address: string): boolean;

package/build/shared/utils/validation.js

@@ -1,27 +0,0 @@
-/**
- * Address validation utilities (dependency-free).
- *
- * openfort-js does not export address validation. The solana-sample example
- * (openfort-js/examples/apps/solana-sample) uses @solana/kit's address() in a
- * try/catch for Solana. We keep this shared util dependency-free so that
- * consumers that don't use @solana/kit (e.g. EVM-only apps) don't pull it in.
- * For stricter Solana validation when @solana/kit is available, use
- * address(addr) from '@solana/kit' in a try/catch. React-native package has no
- * shared address validation (no Send UI with recipient field in the repo).
- */
-const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-function isValidBase58Character(c) {
-    return BASE58_ALPHABET.includes(c);
-}
-/**
- * Validates a Solana address (Base58, 32–44 characters).
- */
-function isValidSolanaAddress(address) {
-    if (typeof address !== 'string' || address.length < 32 || address.length > 44) {
-        return false;
-    }
-    return address.split('').every(isValidBase58Character);
-}
-
-export { isValidSolanaAddress };
-//# sourceMappingURL=validation.js.map

package/build/shared/utils/validation.js.map

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

package/build/solana/constants.d.ts

@@ -1,21 +0,0 @@
-/** System Program's Transfer instruction index (SystemInstruction enum variant 2). */
-export declare const TRANSFER_INSTRUCTION_INDEX = 2;
-export declare const LAMPORTS_PER_SOL: bigint;
-/**
- * Solana System Program address.
- * Not exported by @solana/kit v5 directly — defined here as a typed constant.
- * Source: https://docs.solana.com/developing/runtime-facilities/programs#system-program
- */
-export declare const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
-/**
- * Base fee per signature (5,000 lamports). Does NOT include priority fees,
- * which should be estimated dynamically via getPriorityFeeEstimate.
- * See https://helius.dev/blog/solana-fees-in-theory-and-practice
- */
-export declare const BASE_FEE_LAMPORTS: bigint;
-/**
- * Rent-exempt minimum for a zero-data system account (0 bytes of data).
- * Derived from (128 + 0) bytes * 3,480 lamports/byte-year * 2 years = 890,880 lamports.
- * For accounts with data, use getMinimumBalanceForRentExemption RPC call instead.
- */
-export declare const RENT_EXEMPT_MINIMUM_LAMPORTS: bigint;

package/build/solana/constants.js

@@ -1,24 +0,0 @@
-/** System Program's Transfer instruction index (SystemInstruction enum variant 2). */
-const TRANSFER_INSTRUCTION_INDEX = 2;
-const LAMPORTS_PER_SOL = BigInt(1000000000);
-/**
- * Solana System Program address.
- * Not exported by @solana/kit v5 directly — defined here as a typed constant.
- * Source: https://docs.solana.com/developing/runtime-facilities/programs#system-program
- */
-const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111';
-/**
- * Base fee per signature (5,000 lamports). Does NOT include priority fees,
- * which should be estimated dynamically via getPriorityFeeEstimate.
- * See https://helius.dev/blog/solana-fees-in-theory-and-practice
- */
-const BASE_FEE_LAMPORTS = BigInt(5000);
-/**
- * Rent-exempt minimum for a zero-data system account (0 bytes of data).
- * Derived from (128 + 0) bytes * 3,480 lamports/byte-year * 2 years = 890,880 lamports.
- * For accounts with data, use getMinimumBalanceForRentExemption RPC call instead.
- */
-const RENT_EXEMPT_MINIMUM_LAMPORTS = BigInt(890880);
-
-export { BASE_FEE_LAMPORTS, LAMPORTS_PER_SOL, RENT_EXEMPT_MINIMUM_LAMPORTS, SYSTEM_PROGRAM_ADDRESS, TRANSFER_INSTRUCTION_INDEX };
-//# sourceMappingURL=constants.js.map

package/build/solana/constants.js.map

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

package/build/solana/utils/transfer.d.ts

@@ -1,9 +0,0 @@
-import { AccountRole, address } from '@solana/kit';
-export declare function createTransferSolInstruction(from: string, to: string, lamports: bigint): {
-    programAddress: ReturnType<typeof address>;
-    data: Uint8Array;
-    accounts: Array<{
-        address: ReturnType<typeof address>;
-        role: AccountRole;
-    }>;
-};

package/build/solana/utils/transfer.js

@@ -1,20 +0,0 @@
-import { address, AccountRole } from '@solana/kit';
-import { TRANSFER_INSTRUCTION_INDEX, SYSTEM_PROGRAM_ADDRESS } from '../constants.js';
-
-function createTransferSolInstruction(from, to, lamports) {
-    const data = new Uint8Array(12);
-    const view = new DataView(data.buffer);
-    view.setUint32(0, TRANSFER_INSTRUCTION_INDEX, true);
-    view.setBigUint64(4, lamports, true);
-    return {
-        programAddress: address(SYSTEM_PROGRAM_ADDRESS),
-        data,
-        accounts: [
-            { address: address(from), role: AccountRole.WRITABLE_SIGNER },
-            { address: address(to), role: AccountRole.WRITABLE },
-        ],
-    };
-}
-
-export { createTransferSolInstruction };
-//# sourceMappingURL=transfer.js.map

package/build/solana/utils/transfer.js.map

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