@openfort/react 0.3.1 → 1.0.0

package/build/shared/hooks/useAsyncData.js.map

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

package/build/shared/hooks/useRecoveryOTP.d.ts

@@ -0,0 +1,11 @@
+import { OpenfortError } from '../../core/errors';
+export type OTPResponse = {
+    error?: OpenfortError;
+    sentTo?: 'email' | 'phone';
+    email?: string;
+    phone?: string;
+};
+export declare function useRecoveryOTP(): {
+    isEnabled: boolean;
+    requestOTP: () => Promise<OTPResponse>;
+};

package/build/shared/hooks/useRecoveryOTP.js

@@ -0,0 +1,64 @@
+import { useMemo, useCallback } from 'react';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { logger } from '../../utils/logger.js';
+
+function useRecoveryOTP() {
+    const { client, user } = useOpenfortCore();
+    const { walletConfig } = useOpenfort();
+    const isEnabled = useMemo(() => {
+        return !!walletConfig && (!!walletConfig.requestWalletRecoverOTP || !!walletConfig.requestWalletRecoverOTPEndpoint);
+    }, [walletConfig]);
+    const requestOTP = useCallback(async () => {
+        try {
+            logger.log('Requesting wallet recover OTP for user', { userId: user === null || user === void 0 ? void 0 : user.id });
+            if (!walletConfig) {
+                throw new Error('No walletConfig found');
+            }
+            const accessToken = await client.getAccessToken();
+            if (!accessToken) {
+                throw new OpenfortError('Openfort access token not found', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            if (!(user === null || user === void 0 ? void 0 : user.id)) {
+                throw new OpenfortError('User not found', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            const userId = user.id;
+            const email = user.email;
+            const phone = user.email ? undefined : user.phoneNumber;
+            if (!email && !phone) {
+                throw new OpenfortError('No email or phone number found for user', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            logger.log('Requesting wallet recover OTP for user', { userId, email, phone });
+            if (walletConfig.requestWalletRecoverOTP) {
+                await walletConfig.requestWalletRecoverOTP({ userId, accessToken, email, phone });
+                return { sentTo: email ? 'email' : 'phone', email, phone };
+            }
+            if (!walletConfig.requestWalletRecoverOTPEndpoint) {
+                throw new Error('No requestWalletRecoverOTPEndpoint set in walletConfig');
+            }
+            const resp = await fetch(walletConfig.requestWalletRecoverOTPEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ user_id: userId, email, phone }),
+            });
+            if (!resp.ok) {
+                throw new Error('Failed to request wallet recover OTP');
+            }
+            return { sentTo: email ? 'email' : 'phone', email, phone };
+        }
+        catch (err) {
+            logger.log('Error requesting wallet recover OTP:', err);
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to request wallet recover OTP', OpenfortReactErrorType.WALLET_ERROR);
+            throw error;
+        }
+    }, [walletConfig, client, user]);
+    return { isEnabled, requestOTP };
+}
+
+export { useRecoveryOTP };
+//# sourceMappingURL=useRecoveryOTP.js.map

package/build/shared/hooks/useRecoveryOTP.js.map

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

package/build/shared/types.d.ts

@@ -0,0 +1,65 @@
+import type { AccountTypeEnum, EmbeddedAccount, RecoveryMethod, RecoveryParams } from '@openfort/openfort-js';
+import type { OpenfortHookOptions } from '../types';
+export type RecoverableWallet = {
+    address: string;
+    id: string;
+    recoveryMethod?: RecoveryMethod;
+    accounts: {
+        id: string;
+    }[];
+};
+export type SetRecoveryOptions = {
+    previousRecovery: RecoveryParams;
+    newRecovery: RecoveryParams;
+};
+export type WalletStatus = 'disconnected' | 'fetching-wallets' | 'connecting' | 'reconnecting' | 'creating' | 'needs-recovery' | 'connected' | 'error';
+/** Shared connected wallet state (EVM and Solana embedded hooks). */
+export type ConnectedWalletState = {
+    /** embeddedWalletId when connected (embedded-only hooks). */
+    embeddedWalletId?: string;
+    isConnected: boolean;
+    isConnecting: boolean;
+    isDisconnected: boolean;
+    isReconnecting: boolean;
+};
+/** Derived booleans for consistent hook shape (EVM and Solana). */
+export type WalletDerived = {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+};
+/** Result of creating an embedded wallet (EVM or Solana). */
+export type CreateEmbeddedWalletResult = {
+    account: EmbeddedAccount;
+    error?: string;
+};
+/** Common options for setting active embedded wallet (recovery only; each chain adds address). */
+export type SetActiveEmbeddedWalletOptionsBase = {
+    /** Recovery params for wallet access (escape hatch; prefer named options) */
+    recoveryParams?: RecoveryParams;
+    /** Recovery method when recoveryParams not provided */
+    recoveryMethod?: RecoveryMethod;
+    /** Passkey ID for PASSKEY recovery */
+    passkeyId?: string;
+    /** Password for PASSWORD recovery */
+    password?: string;
+    /** OTP code for AUTOMATIC recovery */
+    otpCode?: string;
+};
+/** Options for creating an embedded wallet (EVM and Solana; EOA and gas sponsorship). */
+export type CreateEmbeddedWalletOptions = {
+    /** Target chain ID for deployment (EVM) */
+    chainId?: number;
+    /** Recovery method for key encryption */
+    recoveryMethod?: RecoveryMethod;
+    /** Passkey ID for PASSKEY recovery */
+    passkeyId?: string;
+    /** Password for PASSWORD recovery */
+    password?: string;
+    /** OTP code for verification */
+    otpCode?: string;
+    /** Account type (EOA, Smart Account, or Delegated Account) */
+    accountType?: AccountTypeEnum;
+    /** Fee sponsorship ID for gas sponsorship */
+    feeSponsorshipId?: string;
+} & OpenfortHookOptions<CreateEmbeddedWalletResult>;

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

@@ -0,0 +1,15 @@
+import type { WalletStatus } from '../types';
+type InternalState<TWallet, TProvider> = {
+    status: WalletStatus;
+    activeWallet: TWallet | null;
+    provider: TProvider | null;
+    error: string | null;
+};
+type StatusResult<TWallet, TProvider, TActions> = TActions & {
+    status: WalletStatus;
+    activeWallet: TWallet | null;
+    provider?: TProvider;
+    error?: string;
+};
+export declare function buildEmbeddedWalletStatusResult<TWallet, TProvider, TActions extends object>(state: InternalState<TWallet, TProvider>, actions: TActions): StatusResult<TWallet, TProvider, TActions>;
+export {};

package/build/shared/utils/embeddedWalletStatusMapper.js

@@ -0,0 +1,22 @@
+function buildStatusResult(state, actions, overrides) {
+    var _a;
+    return { ...actions, status: state.status, activeWallet: (_a = state.activeWallet) !== null && _a !== void 0 ? _a : null, ...overrides };
+}
+const STATUS_RESULT_BUILDERS = {
+    disconnected: (s, a) => buildStatusResult(s, a, { activeWallet: null }),
+    'fetching-wallets': (s, a) => buildStatusResult(s, a, { activeWallet: null }),
+    connecting: (s, a) => buildStatusResult(s, a, { activeWallet: s.activeWallet }),
+    reconnecting: (s, a) => buildStatusResult(s, a, { activeWallet: s.activeWallet }),
+    creating: (s, a) => buildStatusResult(s, a, { activeWallet: null }),
+    'needs-recovery': (s, a) => buildStatusResult(s, a, { activeWallet: s.activeWallet }),
+    connected: (s, a) => buildStatusResult(s, a, { activeWallet: s.activeWallet, provider: s.provider }),
+    error: (s, a) => buildStatusResult(s, a, { activeWallet: s.activeWallet, error: s.error }),
+};
+function buildEmbeddedWalletStatusResult(state, actions) {
+    var _a;
+    const builder = (_a = STATUS_RESULT_BUILDERS[state.status]) !== null && _a !== void 0 ? _a : STATUS_RESULT_BUILDERS.disconnected;
+    return builder(state, actions);
+}
+
+export { buildEmbeddedWalletStatusResult };
+//# sourceMappingURL=embeddedWalletStatusMapper.js.map

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

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

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

@@ -0,0 +1,24 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import type { SolanaCluster } from '../../solana/types';
+/** Options for building a block explorer URL. */
+type ExplorerUrlOptions = {
+    address?: string;
+    txHash?: string;
+    chainId?: number;
+    cluster?: SolanaCluster;
+};
+/**
+ * Builds a block explorer URL for an address or transaction on the given chain.
+ *
+ * @param chainType - EVM or SVM
+ * @param options - address, txHash, chainId (EVM), or cluster (Solana)
+ * @returns Full explorer URL
+ *
+ * @example
+ * ```tsx
+ * const url = getExplorerUrl(ChainTypeEnum.EVM, { address: '0x...', chainId: 1 })
+ * const txUrl = getExplorerUrl(ChainTypeEnum.EVM, { txHash: '0x...', chainId: 1 })
+ * ```
+ */
+export declare function getExplorerUrl(chainType: ChainTypeEnum, options: ExplorerUrlOptions): string;
+export {};

package/build/shared/utils/explorer.js

@@ -0,0 +1,71 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { mainnet, optimism, polygon, base, arbitrum, bsc, polygonAmoy, baseSepolia, beamTestnet, sepolia, optimismSepolia, arbitrumSepolia } from 'viem/chains';
+import { logger } from '../../utils/logger.js';
+
+const SOLANA_EXPLORER_BASE = 'https://explorer.solana.com';
+/** Known EVM chains with block explorers — sourced from viem/chains. */
+const EVM_CHAINS_BY_ID = {
+    [mainnet.id]: mainnet,
+    [optimism.id]: optimism,
+    [polygon.id]: polygon,
+    [base.id]: base,
+    [arbitrum.id]: arbitrum,
+    [bsc.id]: bsc,
+    [polygonAmoy.id]: polygonAmoy,
+    [baseSepolia.id]: baseSepolia,
+    [beamTestnet.id]: beamTestnet,
+    [sepolia.id]: sepolia,
+    [optimismSepolia.id]: optimismSepolia,
+    [arbitrumSepolia.id]: arbitrumSepolia,
+};
+function appendPath(base, options, queryParams) {
+    let path = base;
+    if (options.address)
+        path = `${base}/address/${options.address}`;
+    else if (options.txHash)
+        path = `${base}/tx/${options.txHash}`;
+    return queryParams ? `${path}?${queryParams}` : path;
+}
+const explorerRegistry = {
+    [ChainTypeEnum.EVM]: (options) => {
+        var _a;
+        if (!options.chainId) {
+            logger.warn('No chain ID provided. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.');
+            return polygonAmoy.blockExplorers.default.url;
+        }
+        const chain = EVM_CHAINS_BY_ID[options.chainId];
+        const explorerUrl = (_a = chain === null || chain === void 0 ? void 0 : chain.blockExplorers) === null || _a === void 0 ? void 0 : _a.default.url;
+        if (!explorerUrl) {
+            logger.warn(`No explorer URL found for chain ${options.chainId}. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.`);
+            return polygonAmoy.blockExplorers.default.url;
+        }
+        return appendPath(explorerUrl, options);
+    },
+    [ChainTypeEnum.SVM]: (options) => {
+        if (!options.cluster) {
+            logger.warn('No cluster provided. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.');
+            return appendPath(SOLANA_EXPLORER_BASE, options);
+        }
+        const clusterParam = options.cluster === 'mainnet-beta' ? undefined : `cluster=${encodeURIComponent(options.cluster)}`;
+        return appendPath(SOLANA_EXPLORER_BASE, options, clusterParam);
+    },
+};
+/**
+ * Builds a block explorer URL for an address or transaction on the given chain.
+ *
+ * @param chainType - EVM or SVM
+ * @param options - address, txHash, chainId (EVM), or cluster (Solana)
+ * @returns Full explorer URL
+ *
+ * @example
+ * ```tsx
+ * const url = getExplorerUrl(ChainTypeEnum.EVM, { address: '0x...', chainId: 1 })
+ * const txUrl = getExplorerUrl(ChainTypeEnum.EVM, { txHash: '0x...', chainId: 1 })
+ * ```
+ */
+function getExplorerUrl(chainType, options) {
+    return explorerRegistry[chainType](options);
+}
+
+export { getExplorerUrl };
+//# sourceMappingURL=explorer.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { OpenfortError } from '../../core/errors';
+type HandleOtpErrorResult = {
+    error: OpenfortError;
+    isOTPRequired: boolean;
+};
+/** Normalizes OTP_REQUIRED errors and returns user-friendly messages. */
+export declare function handleOtpRecoveryError(error: Error | unknown, hasWalletRecoveryOTP: boolean): HandleOtpErrorResult;
+export {};

package/build/shared/utils/otpError.js

@@ -0,0 +1,17 @@
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+
+/** Normalizes OTP_REQUIRED errors and returns user-friendly messages. */
+function handleOtpRecoveryError(error, hasWalletRecoveryOTP) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg !== 'OTP_REQUIRED') {
+        const normalized = error instanceof OpenfortError ? error : new OpenfortError(msg, OpenfortReactErrorType.UNEXPECTED_ERROR);
+        return { error: normalized, isOTPRequired: false };
+    }
+    const newError = hasWalletRecoveryOTP
+        ? new OpenfortError('OTP code is required to recover the wallet.', OpenfortReactErrorType.WALLET_ERROR)
+        : new OpenfortError('OTP code is required to recover the wallet.\nPlease set requestWalletRecoveryOTP or requestWalletRecoveryOTPEndpoint in OpenfortProvider.', OpenfortReactErrorType.WALLET_ERROR);
+    return { error: newError, isOTPRequired: true };
+}
+
+export { handleOtpRecoveryError };
+//# sourceMappingURL=otpError.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { RecoveryMethod, type RecoveryParams } from '@openfort/openfort-js';
+import type { OpenfortWalletConfig } from '../../components/Openfort/types';
+type RecoveryOptions = {
+    recoveryMethod?: RecoveryMethod;
+    passkeyId?: string;
+    password?: string;
+    otpCode?: string;
+};
+export type BuildRecoveryParamsConfig = {
+    walletConfig: OpenfortWalletConfig | undefined;
+    getAccessToken: () => Promise<string | null>;
+    getUserId: () => Promise<string | undefined>;
+};
+export declare function buildRecoveryParams(options: RecoveryOptions | undefined, config: BuildRecoveryParamsConfig): Promise<RecoveryParams>;
+export {};

package/build/shared/utils/recovery.js

@@ -0,0 +1,96 @@
+import { RecoveryMethod } from '@openfort/openfort-js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+
+async function buildRecoveryParams(options, config) {
+    var _a;
+    const { walletConfig, getAccessToken, getUserId } = config;
+    const recoveryMethod = (_a = options === null || options === void 0 ? void 0 : options.recoveryMethod) !== null && _a !== void 0 ? _a : RecoveryMethod.AUTOMATIC;
+    switch (recoveryMethod) {
+        case RecoveryMethod.AUTOMATIC: {
+            const accessToken = await getAccessToken();
+            if (!accessToken) {
+                throw new OpenfortError('Access token not found', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            const userId = await getUserId();
+            if (!userId) {
+                throw new OpenfortError('User not found', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            const encryptionSession = await getEncryptionSession({
+                accessToken,
+                userId,
+                otpCode: options === null || options === void 0 ? void 0 : options.otpCode,
+                walletConfig,
+            });
+            return {
+                recoveryMethod: RecoveryMethod.AUTOMATIC,
+                encryptionSession,
+            };
+        }
+        case RecoveryMethod.PASSWORD: {
+            if (!(options === null || options === void 0 ? void 0 : options.password)) {
+                throw new OpenfortError('Password is required', OpenfortReactErrorType.CONFIGURATION_ERROR);
+            }
+            return {
+                recoveryMethod: RecoveryMethod.PASSWORD,
+                password: options.password,
+            };
+        }
+        case RecoveryMethod.PASSKEY:
+            return {
+                recoveryMethod: RecoveryMethod.PASSKEY,
+                ...((options === null || options === void 0 ? void 0 : options.passkeyId) && { passkeyInfo: { passkeyId: options.passkeyId } }),
+            };
+        default:
+            throw new OpenfortError('Unsupported recovery method', OpenfortReactErrorType.UNEXPECTED_ERROR, {
+                recoveryMethod,
+            });
+    }
+}
+async function getEncryptionSession(params) {
+    var _a, _b;
+    const { accessToken, userId, otpCode, walletConfig } = params;
+    if (!walletConfig) {
+        throw new OpenfortError('Wallet config not found', OpenfortReactErrorType.CONFIGURATION_ERROR);
+    }
+    if (walletConfig.getEncryptionSession) {
+        const session = await walletConfig.getEncryptionSession({ accessToken, userId, otpCode });
+        if (typeof session !== 'string' || session.length === 0) {
+            throw new OpenfortError('getEncryptionSession returned invalid session', OpenfortReactErrorType.WALLET_ERROR);
+        }
+        return session;
+    }
+    if (walletConfig.createEncryptedSessionEndpoint) {
+        const response = await fetch(walletConfig.createEncryptedSessionEndpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ user_id: userId, otp_code: otpCode }),
+        });
+        let data;
+        try {
+            data = (await response.json());
+        }
+        catch {
+            data = {};
+        }
+        if (!response.ok) {
+            if (data.error === 'OTP_REQUIRED') {
+                throw new OpenfortError('OTP verification required', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            const errMsg = typeof ((_a = data.error) !== null && _a !== void 0 ? _a : data.message) === 'string'
+                ? `Failed to create encryption session: ${(_b = data.error) !== null && _b !== void 0 ? _b : data.message}`
+                : 'Failed to create encryption session';
+            throw new OpenfortError(errMsg, OpenfortReactErrorType.WALLET_ERROR, {
+                error: data.error != null ? new Error(String(data.error)) : undefined,
+            });
+        }
+        const session = data.session;
+        if (typeof session !== 'string' || session.length === 0) {
+            throw new OpenfortError('Invalid encryption session response', OpenfortReactErrorType.WALLET_ERROR);
+        }
+        return session;
+    }
+    throw new OpenfortError('No encryption session method configured. Provide getEncryptionSession or createEncryptedSessionEndpoint in walletConfig.', OpenfortReactErrorType.CONFIGURATION_ERROR);
+}
+
+export { buildRecoveryParams };
+//# sourceMappingURL=recovery.js.map

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1,27 @@
+/**
+ * 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

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

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

@@ -0,0 +1,18 @@
+import type { WalletStatus } from '../types';
+/**
+ * Maps wallet status + activeWallet presence to the derived boolean/id props
+ * shared by both Ethereum and Solana embedded wallet hooks.
+ */
+export declare function toConnectedStateProperties(status: WalletStatus, activeWallet: object | null): {
+    embeddedWalletId: undefined;
+    isConnected: boolean;
+    isConnecting: boolean;
+    isDisconnected: boolean;
+    isReconnecting: boolean;
+} | {
+    embeddedWalletId: string;
+    isConnected: boolean;
+    isConnecting: boolean;
+    isDisconnected: boolean;
+    isReconnecting: boolean;
+};

package/build/shared/utils/walletStatusProps.js

@@ -0,0 +1,45 @@
+import { embeddedWalletId } from '../../constants/openfort.js';
+
+/**
+ * Maps wallet status + activeWallet presence to the derived boolean/id props
+ * shared by both Ethereum and Solana embedded wallet hooks.
+ */
+function toConnectedStateProperties(status, activeWallet) {
+    if (status === 'creating' || status === 'fetching-wallets') {
+        return {
+            embeddedWalletId: undefined,
+            isConnected: false,
+            isConnecting: true,
+            isDisconnected: false,
+            isReconnecting: false,
+        };
+    }
+    if (status === 'connecting' || status === 'reconnecting') {
+        return {
+            embeddedWalletId,
+            isConnected: false,
+            isConnecting: true,
+            isDisconnected: false,
+            isReconnecting: status === 'reconnecting',
+        };
+    }
+    if ((status === 'connected' || status === 'needs-recovery') && activeWallet) {
+        return {
+            embeddedWalletId,
+            isConnected: status === 'connected',
+            isConnecting: false,
+            isDisconnected: false,
+            isReconnecting: false,
+        };
+    }
+    return {
+        embeddedWalletId: undefined,
+        isConnected: false,
+        isConnecting: false,
+        isDisconnected: true,
+        isReconnecting: false,
+    };
+}
+
+export { toConnectedStateProperties };
+//# sourceMappingURL=walletStatusProps.js.map

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

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

package/build/siwe/create-siwe-message.d.ts

@@ -1 +1,15 @@
-export declare const createSIWEMessage: (address: `0x${string}`, nonce: string, chainId: number) => string;
+/**
+ * Creates a SIWE message for wallet auth. Uses current domain and origin.
+ * Safe for SSR: returns undefined when window is not available.
+ *
+ * @param address - Wallet address to sign
+ * @param nonce - Server-provided nonce
+ * @param chainId - Chain ID for the message
+ *
+ * @example
+ * ```tsx
+ * const message = createSIWEMessage(address, nonce, chainId)
+ * const signature = await signMessage({ message })
+ * ```
+ */
+export declare const createSIWEMessage: (address: `0x${string}`, nonce: string, chainId: number) => string | undefined;

package/build/siwe/create-siwe-message.js

@@ -0,0 +1,32 @@
+import { createSiweMessage } from 'viem/siwe';
+
+/**
+ * Creates a SIWE message for wallet auth. Uses current domain and origin.
+ * Safe for SSR: returns undefined when window is not available.
+ *
+ * @param address - Wallet address to sign
+ * @param nonce - Server-provided nonce
+ * @param chainId - Chain ID for the message
+ *
+ * @example
+ * ```tsx
+ * const message = createSIWEMessage(address, nonce, chainId)
+ * const signature = await signMessage({ message })
+ * ```
+ */
+const createSIWEMessage = (address, nonce, chainId) => {
+    if (typeof window === 'undefined')
+        return undefined;
+    return createSiweMessage({
+        domain: window.location.host,
+        address,
+        statement: 'By signing, you are proving you own this wallet and logging in. This does not initiate a transaction or cost any fees.',
+        uri: window.location.origin,
+        version: '1',
+        chainId: chainId,
+        nonce,
+    });
+};
+
+export { createSIWEMessage };
+//# sourceMappingURL=create-siwe-message.js.map

package/build/siwe/create-siwe-message.js.map

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

package/build/solana/SolanaContext.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Solana Context Provider
+ *
+ * Provides Solana configuration (cluster, RPC URL, commitment) to descendant components.
+ * Cluster is fixed at config time and cannot be changed at runtime.
+ */
+import { type ReactNode } from 'react';
+import type { SolanaCluster, SolanaCommitment, SolanaConfig } from './types';
+/**
+ * Solana context value with resolved configuration
+ */
+interface SolanaContextValue {
+    /** Active Solana cluster */
+    cluster: SolanaCluster;
+    /** RPC URL (resolved from config or default) */
+    rpcUrl: string;
+    /** Transaction commitment level */
+    commitment: SolanaCommitment;
+}
+interface SolanaContextProviderProps {
+    /** Solana configuration from OpenfortWalletConfig */
+    config: SolanaConfig;
+    /** Child components */
+    children: ReactNode;
+}
+export declare const SolanaContext: import("react").Context<SolanaContextValue | null>;
+export declare function SolanaContextProvider({ config, children }: SolanaContextProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the Solana context configuration.
+ *
+ * @throws Error if called outside of a SolanaContextProvider
+ * (i.e., when `walletConfig.solana` is not configured in OpenfortProvider)
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { cluster, rpcUrl, commitment } = useSolanaContext();
+ *   // Use Solana configuration...
+ * }
+ * ```
+ */
+export declare function useSolanaContext(): SolanaContextValue;
+export {};