@rockerone/xprnkit 0.3.3 → 0.3.5

package/build/providers/XPRNProvider.js

@@ -2,132 +2,165 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ApiClass } from "@proton/api";
 import ConnectWallet from "@proton/web-sdk";
-import React, { useCallback, useContext, useEffect, useMemo, useReducer, useRef, } from "react";
+import React, { useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { JsonRpc } from "@proton/js";
-import { parseTransactionErrorMessage } from "../utils";
-import { createIdentityProof, verifyIdentityProof, } from "../services/identity-proof";
+import { sessionStorage, parseTransactionErrorMessage } from "../utils";
+import { createIdentityProof, verifyIdentityProof, validateIdentityProof, parseToken, isTokenExpired, } from "../services/identity-proof";
 const XPRNContext = React.createContext({
+    config: null,
     session: null,
     link: null,
     profile: null,
     rpc: null,
-    txErrorsStack: null,
+    identityProof: null,
+    identityProofStatus: "idle",
+    needsIdentityProof: false,
+    isIdentityProofRequired: false,
+    isIdentityProofEnabled: false,
     connect: () => { },
-    disconnect: () => { },
-    addTransactionError() { },
+    disconnect: async () => { },
+    requestIdentityProof: () => { },
+    listStoredSessions: () => [],
+    switchToSession: async () => { },
+    addTransactionError: () => { },
+    // Legacy
     authentication: null,
-    authenticate: () => { },
-    getActiveSession: () => null,
-    listSessions: () => [],
-    setActiveSession: () => { },
-    removeSession: async () => { },
-    getAllProfiles: () => [],
-    switchSession: () => { },
-    getSessionById: () => null,
-    getSessionByActor: () => null,
     authStatus: "idle",
-    getAuthStatus: () => "idle",
+    authenticate: () => { },
 });
 export const XPRNProvider = ({ children, config, }) => {
-    // Force update mechanism - only triggers re-render when active session changes
-    const [version, forceUpdate] = useReducer((x) => x + 1, 0);
-    // Internal refs - no re-renders when mutated
-    const sessionsRef = useRef(new Map());
-    const activeSessionIdRef = useRef(null);
+    // Simple state for single active session
+    const [session, setSession] = useState(null);
+    const [link, setLink] = useState(null);
+    const [profile, setProfile] = useState(null);
+    const [identityProof, setIdentityProof] = useState(null);
+    const [identityProofStatus, setIdentityProofStatus] = useState("idle");
+    // Compute identity proof config (supports both new and legacy config)
+    const identityProofConfig = useMemo(() => {
+        if (config.identityProof) {
+            return config.identityProof;
+        }
+        // Legacy support
+        if (config.authenticationUrl) {
+            return {
+                createUrl: config.authenticationUrl,
+                enforceOnConnect: config.enforceAuthentication,
+            };
+        }
+        return null;
+    }, [config.identityProof, config.authenticationUrl, config.enforceAuthentication]);
+    // Helper booleans
+    const isIdentityProofEnabled = identityProofConfig !== null;
+    const isIdentityProofRequired = identityProofConfig?.required ?? false;
+    const needsIdentityProof = isIdentityProofEnabled && session !== null && identityProof === null;
+    // Internal refs
     const jsonRpcRef = useRef(new JsonRpc(config.endpoints));
     const errorsStackRef = useRef([]);
     const onSessionRef = useRef();
     const onProfileRef = useRef();
     const isRestoringRef = useRef(false);
-    // Authentication refs - for duplicate prevention and cancellation
-    const authStatusRef = useRef(new Map());
-    const authenticatingRef = useRef(new Set());
-    const authAbortControllersRef = useRef(new Map());
-    // Derived values - recomputed only when version changes (active session affected)
-    const { activeSession, session, link, profile, authentication, authStatus } = useMemo(() => {
-        const active = activeSessionIdRef.current
-            ? sessionsRef.current.get(activeSessionIdRef.current) ?? null
-            : null;
-        const status = activeSessionIdRef.current
-            ? authStatusRef.current.get(activeSessionIdRef.current) ?? "idle"
-            : "idle";
-        return {
-            activeSession: active,
-            session: active?.session ?? null,
-            link: active?.link ?? null,
-            profile: active?.profile ?? null,
-            authentication: active?.authentication ?? null,
-            authStatus: status,
-        };
-    }, [version]);
-    // Get auth status for any actor
-    const getAuthStatus = useCallback((actor) => {
-        const target = actor || activeSessionIdRef.current;
-        return target ? authStatusRef.current.get(target) ?? "idle" : "idle";
-    }, []);
-    // Session management methods - stable callbacks using refs
-    const getActiveSession = useCallback(() => {
-        return activeSessionIdRef.current
-            ? sessionsRef.current.get(activeSessionIdRef.current) ?? null
-            : null;
-    }, []);
-    const listSessions = useCallback(() => {
-        return Array.from(sessionsRef.current.values());
-    }, []);
-    const setActiveSession = useCallback((actor) => {
-        if (sessionsRef.current.has(actor)) {
-            activeSessionIdRef.current = actor;
-            // Store in localStorage for persistence
-            if (typeof window !== "undefined") {
-                localStorage.setItem("xprn_active_session_actor", actor);
+    const isAuthenticatingRef = useRef(false);
+    const isSwitchingSessionRef = useRef(false);
+    // List stored sessions from proton-web-sdk localStorage
+    const listStoredSessions = useCallback(() => {
+        return sessionStorage.getLinkList(config.requesterAccount);
+    }, [config.requesterAccount]);
+    // Switch to a different stored session using link.restoreSession
+    const switchToSession = useCallback(async (auth, chainId) => {
+        if (!link) {
+            console.warn("Cannot switch session: No link available. Call connect() first.");
+            return;
+        }
+        // Mark that we're switching sessions to prevent useEffect interference
+        isSwitchingSessionRef.current = true;
+        // Parse auth string (format: "actor@permission")
+        const [actor, permission] = auth.split('@');
+        const authObj = { actor, permission };
+        // Use link.restoreSession to restore the session
+        // Both Link and ProtonWebLink support this method (with different return types)
+        const restoredSession = await link.restoreSession(config.requesterAccount, authObj, chainId);
+        if (!restoredSession) {
+            throw new Error(`Failed to restore session for ${auth} on chain ${chainId}`);
+        }
+        // Clear identity proof state immediately for the new session
+        setSession(restoredSession);
+        // Check if the new session has a stored identity proof token
+        const storedEntry = sessionStorage.get(config.requesterAccount, { actor: actor, permission: permission }, chainId);
+        if (storedEntry?.identityProofToken && identityProofConfig?.validationUrl) {
+            // New session has a stored token - validate it
+            setIdentityProofStatus("validating");
+            try {
+                const tokenClaims = parseToken(storedEntry.identityProofToken);
+                if (tokenClaims && !isTokenExpired(tokenClaims)) {
+                    // Token exists and not expired - validate with backend
+                    const result = await validateIdentityProof({
+                        validationUrl: identityProofConfig.validationUrl,
+                        token: storedEntry.identityProofToken,
+                        headers: identityProofConfig.headers,
+                        timeout: identityProofConfig.timeout,
+                    });
+                    if (result.valid) {
+                        const newToken = result.token || storedEntry.identityProofToken;
+                        setIdentityProof({
+                            actor: actor,
+                            publicKey: "",
+                            token: newToken,
+                        });
+                        setIdentityProofStatus("success");
+                        // Update token in storage if refreshed
+                        if (result.token && result.token !== storedEntry.identityProofToken) {
+                            sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor: actor, permission: permission }, chainId, result.token);
+                        }
+                    }
+                    else {
+                        // Token invalid - clear it
+                        sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor: actor, permission: permission }, chainId, null);
+                        setIdentityProof(null);
+                        setIdentityProofStatus("expired");
+                    }
+                }
+                else {
+                    // Token expired or invalid - clear it
+                    sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor: actor, permission: permission }, chainId, null);
+                    setIdentityProof(null);
+                    setIdentityProofStatus("expired");
+                }
+            }
+            catch (error) {
+                console.error("Failed to validate token during session switch:", error);
+                setIdentityProof(null);
+                setIdentityProofStatus("error");
             }
-            // Trigger re-render for consumers
-            forceUpdate();
         }
         else {
-            console.warn(`Session with actor ${actor} not found`);
-        }
-    }, [forceUpdate]);
-    const switchSession = useCallback((actor) => {
-        setActiveSession(actor);
-    }, [setActiveSession]);
-    const getSessionById = useCallback((actor) => {
-        return sessionsRef.current.get(actor) ?? null;
-    }, []);
-    const getSessionByActor = useCallback((actor) => {
-        return sessionsRef.current.get(actor) ?? null;
-    }, []);
-    const removeSession = useCallback(async (actor) => {
-        const sessionToRemove = sessionsRef.current.get(actor);
-        if (!sessionToRemove) {
-            console.warn(`Session with actor ${actor} not found`);
-            return;
+            // No stored token for this session - clear identity proof state
+            setIdentityProof(null);
+            setIdentityProofStatus("idle");
         }
-        // Remove session from the link
+        // Fetch profile for new session
+        const api = new ApiClass(config.apiMode === "testnet" ? "proton-test" : "proton");
         try {
-            await sessionToRemove.link.removeSession(config.requesterAccount, sessionToRemove.session.auth, sessionToRemove.session.chainId);
+            const profileRes = await api.getProtonAvatar(actor);
+            if (profileRes) {
+                setProfile({
+                    displayName: profileRes.name,
+                    avatar: profileRes.avatar,
+                    isKyc: profileRes.kyc.length > 0,
+                });
+            }
         }
-        catch (e) {
-            console.error("Error removing session from link:", e);
+        catch (error) {
+            console.error("Failed to fetch profile after session switch:", error);
         }
-        // Remove from sessions map (mutate ref directly)
-        sessionsRef.current.delete(actor);
-        // If this was the active session, clear it and trigger re-render
-        if (activeSessionIdRef.current === actor) {
-            activeSessionIdRef.current = null;
-            if (typeof window !== "undefined") {
-                localStorage.removeItem("xprn_active_session_actor");
-            }
-            forceUpdate();
+        // Trigger onSession callback if set
+        if (onSessionRef.current) {
+            onSessionRef.current(restoredSession, link);
+            onSessionRef.current = undefined;
         }
-    }, [config.requesterAccount, forceUpdate]);
-    const getAllProfiles = useCallback(() => {
-        return Array.from(sessionsRef.current.values())
-            .map(s => s.profile)
-            .filter((p) => p !== null);
-    }, []);
+        // Mark session switch as complete
+        isSwitchingSessionRef.current = false;
+    }, [link, config.requesterAccount, config.apiMode, identityProofConfig]);
     const connect = useCallback((restoreSession, onSession, onProfile) => {
-        console.log("restoreSession", restoreSession);
         ConnectWallet({
             linkOptions: {
                 endpoints: config.endpoints,
@@ -143,241 +176,265 @@ export const XPRNProvider = ({ children, config, }) => {
             onSessionRef.current = onSession;
             onProfileRef.current = onProfile;
             if (res.link && res.session) {
+                // Update state with new session
+                setLink(res.link);
+                setSession(res.session);
+                // Clear identity proof state for new session - it will be restored if stored token exists
+                setIdentityProof(null);
+                setIdentityProofStatus("idle");
                 const actor = res.session.auth.actor.toString();
-                // Create initial session object with null profile
-                const newSession = {
-                    actor,
-                    session: res.session,
-                    link: res.link,
-                    profile: null,
-                    authentication: null,
-                };
-                // Add to sessions map (mutate ref directly)
-                sessionsRef.current.set(actor, newSession);
-                // Auto-switch to newly connected session
-                activeSessionIdRef.current = actor;
-                if (typeof window !== "undefined") {
-                    localStorage.setItem("xprn_active_session_actor", actor);
+                // Trigger onSession callback
+                if (onSession) {
+                    onSession(res.session, res.link);
                 }
-                // Trigger re-render since active session changed
-                forceUpdate();
                 // Fetch profile data
-                const api = new ApiClass(config.apiMode && config.apiMode == "testnet"
-                    ? "proton-test"
-                    : "proton");
+                const api = new ApiClass(config.apiMode === "testnet" ? "proton-test" : "proton");
+                const permission = res.session.auth.permission.toString();
+                const chainId = res.session.chainId.toString();
                 api.getProtonAvatar(actor).then(profileRes => {
                     if (profileRes) {
                         const xprProfile = {
                             displayName: profileRes.name,
                             avatar: `${profileRes.avatar}`,
-                            isKyc: profileRes.kyc.length > 0 || false,
+                            isKyc: profileRes.kyc.length > 0,
                         };
-                        // Update session with profile (mutate ref)
-                        const existingSession = sessionsRef.current.get(actor);
-                        if (existingSession) {
-                            sessionsRef.current.set(actor, {
-                                ...existingSession,
-                                profile: xprProfile,
-                            });
-                        }
-                        // Only trigger re-render if this is still the active session
-                        if (activeSessionIdRef.current === actor) {
-                            forceUpdate();
+                        setProfile(xprProfile);
+                        // Save session data to storage, preserving existing token if present
+                        const existingEntry = sessionStorage.get(config.requesterAccount, { actor, permission }, chainId);
+                        sessionStorage.save(config.requesterAccount, {
+                            auth: { actor, permission },
+                            chainId,
+                            profile: xprProfile,
+                            identityProofToken: existingEntry?.identityProofToken ?? null,
+                        });
+                        if (onProfile) {
+                            onProfile(xprProfile);
                         }
                     }
                 });
             }
         });
-    }, [config, forceUpdate]);
-    const disconnect = useCallback(async (actor) => {
-        // If actor is provided, disconnect that specific session
-        // Otherwise, disconnect the active session
-        const targetActor = actor || activeSessionIdRef.current;
-        if (!targetActor) {
+    }, [config]);
+    const disconnect = useCallback(async () => {
+        if (!session || !link) {
             console.warn("No session to disconnect");
             return;
         }
-        await removeSession(targetActor);
-    }, [removeSession]);
+        try {
+            await link.removeSession(config.requesterAccount, session.auth, session.chainId);
+        }
+        catch (e) {
+            console.error("Error removing session:", e);
+        }
+        // Clear state
+        setSession(null);
+        setProfile(null);
+        setIdentityProof(null);
+        setIdentityProofStatus("idle");
+        // Note: Keep link reference for potential session switching
+    }, [session, link, config.requesterAccount]);
     const addTxError = useCallback((message) => {
         errorsStackRef.current.push(parseTransactionErrorMessage(message));
     }, []);
-    const authenticate = useCallback(async (success, fail, actor) => {
-        // Use provided actor or active session
-        const targetActor = actor || activeSessionIdRef.current;
-        if (!targetActor) {
-            fail(new Error("No session available for authentication"));
-            return;
-        }
-        const targetSession = sessionsRef.current.get(targetActor);
-        if (!targetSession) {
-            fail(new Error(`Session not found for actor: ${targetActor}`));
+    const requestIdentityProof = useCallback(async (success, fail) => {
+        if (!session) {
+            fail(new Error("No session available for identity proof"));
             return;
         }
-        if (!config.authenticationUrl) {
-            fail(new Error("Authentication URL not configured"));
+        if (!identityProofConfig) {
+            fail(new Error("Identity proof not configured"));
             return;
         }
-        // Prevent duplicate requests
-        if (authenticatingRef.current.has(targetActor)) {
-            fail(new Error(`Authentication already in progress for ${targetActor}`));
+        if (isAuthenticatingRef.current) {
+            fail(new Error("Identity proof already in progress"));
             return;
         }
-        // Cancel any previous request for this actor
-        authAbortControllersRef.current.get(targetActor)?.abort();
-        const abortController = new AbortController();
-        authAbortControllersRef.current.set(targetActor, abortController);
-        authenticatingRef.current.add(targetActor);
-        // Update status
-        const updateStatus = (status) => {
-            authStatusRef.current.set(targetActor, status);
-            if (activeSessionIdRef.current === targetActor) {
-                forceUpdate();
-            }
-        };
+        isAuthenticatingRef.current = true;
         try {
             // Step 1: Sign with wallet
-            updateStatus("signing");
-            const proof = await createIdentityProof(targetSession.session, {
-                signal: abortController.signal,
-            });
+            setIdentityProofStatus("signing");
+            const proof = await createIdentityProof(session);
             // Step 2: Verify with backend
-            updateStatus("verifying");
-            const authRes = await verifyIdentityProof(proof, { authenticationUrl: config.authenticationUrl }, { signal: abortController.signal });
-            // Step 3: Update session with authentication data
-            const authData = {
+            setIdentityProofStatus("verifying");
+            const verifyRes = await verifyIdentityProof(proof, { createUrl: identityProofConfig.createUrl, headers: identityProofConfig.headers });
+            // Step 3: Update state with identity proof data
+            const identityProofData = {
                 publicKey: proof.signer.publicKey,
                 actor: proof.signer.actor,
-                data: authRes,
+                token: verifyRes.token,
+                data: verifyRes,
             };
-            const existingSession = sessionsRef.current.get(targetActor);
-            if (existingSession) {
-                sessionsRef.current.set(targetActor, {
-                    ...existingSession,
-                    authentication: authData,
-                });
+            setIdentityProof(identityProofData);
+            setIdentityProofStatus("success");
+            // Save token to storage
+            if (verifyRes.token) {
+                const actor = session.auth.actor.toString();
+                const permission = session.auth.permission.toString();
+                const chainId = session.chainId.toString();
+                sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor, permission }, chainId, verifyRes.token);
             }
-            // Success
-            updateStatus("success");
-            success(authRes);
+            success(identityProofData);
         }
         catch (error) {
-            // Handle abort silently
-            if (error instanceof Error && error.name === "AbortError") {
-                updateStatus("idle");
-                return;
-            }
-            // Handle other errors
-            updateStatus("error");
+            setIdentityProofStatus("error");
             fail(error);
         }
         finally {
-            authenticatingRef.current.delete(targetActor);
-            if (authAbortControllersRef.current.get(targetActor) === abortController) {
-                authAbortControllersRef.current.delete(targetActor);
-            }
+            isAuthenticatingRef.current = false;
         }
-    }, [config.authenticationUrl, forceUpdate]);
-    // Handle authentication for active session
-    useEffect(() => {
-        if (session && activeSessionIdRef.current) {
-            const currentSession = sessionsRef.current.get(activeSessionIdRef.current);
-            if (currentSession && !currentSession.authentication) {
-                if (config.enforceAuthentication && config.authenticationUrl) {
-                    authenticate(() => {
-                        console.log(`[XPRNProvider] Auto-authenticated: ${activeSessionIdRef.current}`);
-                    }, error => {
-                        console.error("[XPRNProvider] Auto-authentication failed:", error);
-                    });
+    }, [session, identityProofConfig, config.requesterAccount]);
+    // Legacy alias
+    const authenticate = requestIdentityProof;
+    // Validate stored token silently
+    const validateStoredToken = useCallback(async (actor, permission, chainId) => {
+        if (!identityProofConfig?.validationUrl) {
+            return false;
+        }
+        // Get stored token from session storage
+        const storedEntry = sessionStorage.get(config.requesterAccount, { actor, permission }, chainId);
+        const storedToken = storedEntry?.identityProofToken;
+        if (!storedToken) {
+            return false;
+        }
+        // Parse token to check if it's expired
+        const tokenClaims = parseToken(storedToken);
+        if (!tokenClaims) {
+            return false;
+        }
+        // Check if token is expired
+        if (isTokenExpired(tokenClaims)) {
+            // Clear expired token from storage
+            sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor, permission }, chainId, null);
+            return false;
+        }
+        // Validate token with backend
+        setIdentityProofStatus("validating");
+        try {
+            const result = await validateIdentityProof({
+                validationUrl: identityProofConfig.validationUrl,
+                token: storedToken,
+                headers: identityProofConfig.headers,
+                timeout: identityProofConfig.timeout,
+            });
+            if (result.valid) {
+                // Token is valid - update state
+                const newToken = result.token || storedToken;
+                setIdentityProof({
+                    actor,
+                    publicKey: "", // We don't have public key from stored token
+                    token: newToken,
+                });
+                setIdentityProofStatus("success");
+                // Update token in storage if refreshed
+                if (result.token && result.token !== storedToken) {
+                    sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor, permission }, chainId, result.token);
                 }
+                return true;
+            }
+            else {
+                // Clear invalid token from storage
+                sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor, permission }, chainId, null);
+                setIdentityProofStatus("expired");
+                return false;
             }
         }
-        if (session && onSessionRef.current) {
-            onSessionRef.current(session);
-            onSessionRef.current = undefined; // Reset the ref
+        catch (error) {
+            console.error("[XPRNProvider] Token validation error:", error);
+            setIdentityProofStatus("error");
+            return false;
         }
-    }, [
-        session,
-        authenticate,
-        config.enforceAuthentication,
-        config.authenticationUrl,
-    ]);
-    // Cleanup abort controllers on unmount
+    }, [identityProofConfig, config.requesterAccount]);
+    // Handle token restoration and auto-authentication when session is established
+    // Note: This effect is skipped when switchToSession is handling the identity proof state
     useEffect(() => {
-        return () => {
-            authAbortControllersRef.current.forEach(controller => controller.abort());
-            authAbortControllersRef.current.clear();
-        };
-    }, []);
+        // Skip if we're in the middle of a session switch (switchToSession handles this)
+        if (isSwitchingSessionRef.current)
+            return;
+        if (!session || identityProof)
+            return;
+        if (!identityProofConfig)
+            return;
+        const actor = session.auth.actor.toString();
+        const permission = session.auth.permission.toString();
+        const chainId = session.chainId.toString();
+        // Check if there's a stored token and try to validate it
+        const storedEntry = sessionStorage.get(config.requesterAccount, { actor, permission }, chainId);
+        if (storedEntry?.identityProofToken) {
+            // Try to validate stored token silently
+            validateStoredToken(actor, permission, chainId).then(isValid => {
+                if (!isValid && (identityProofConfig.enforceOnConnect || identityProofConfig.required)) {
+                    // Token invalid and identity proof is required - trigger full auth flow
+                    requestIdentityProof(() => { }, () => { });
+                }
+            });
+        }
+        else if (identityProofConfig.enforceOnConnect) {
+            // No stored token but enforceOnConnect is enabled - trigger auth flow
+            requestIdentityProof(() => { }, () => { });
+        }
+    }, [session, identityProof, identityProofConfig, config.requesterAccount, validateStoredToken, requestIdentityProof]);
     // Handle profile callbacks
     useEffect(() => {
         if (profile && onProfileRef.current) {
             onProfileRef.current(profile);
-            onProfileRef.current = undefined; // Reset the ref
+            onProfileRef.current = undefined;
         }
     }, [profile]);
-    // Session restoration - only restore active session (runs once on mount)
+    // Session restoration on mount
     useEffect(() => {
         if (isRestoringRef.current)
             return;
-        if (sessionsRef.current.size === 0 && config.restoreSession) {
-            // Check if there's a stored active session
-            if (typeof window !== "undefined") {
-                const storedActiveActor = localStorage.getItem("xprn_active_session_actor");
-                if (storedActiveActor) {
-                    isRestoringRef.current = true;
-                    // Try to restore the session
-                    connect(true);
-                }
-            }
+        if (!session && config.restoreSession) {
+            isRestoringRef.current = true;
+            connect(true);
         }
-    }, [config.restoreSession, connect]);
+    }, [config.restoreSession, connect, session]);
     const providerValue = useMemo(() => {
         return {
-            // Backward compatibility - active session values (reactive via version)
+            // Config
+            config,
+            // Session state
             session,
             link,
             profile,
             rpc: jsonRpcRef.current,
-            addTransactionError: addTxError,
+            // Identity proof state
+            identityProof,
+            identityProofStatus,
+            // Helper booleans
+            needsIdentityProof,
+            isIdentityProofRequired,
+            isIdentityProofEnabled,
+            // Core methods
             connect,
             disconnect,
-            authenticate,
-            authentication,
-            // Multi-session management methods (stable references)
-            getActiveSession,
-            listSessions,
-            setActiveSession,
-            removeSession,
-            getAllProfiles,
-            switchSession,
-            getSessionById,
-            getSessionByActor,
-            // Authentication status
-            authStatus,
-            getAuthStatus,
+            requestIdentityProof,
+            // Session switching
+            listStoredSessions,
+            switchToSession,
+            // Utility
+            addTransactionError: addTxError,
+            // Legacy aliases
+            authentication: identityProof,
+            authStatus: identityProofStatus,
+            authenticate: requestIdentityProof,
         };
     }, [
-        // Reactive values (change when active session changes)
+        config,
         session,
         link,
         profile,
-        authentication,
-        authStatus,
-        // Stable callbacks (only change when their specific deps change)
-        addTxError,
+        identityProof,
+        identityProofStatus,
+        needsIdentityProof,
+        isIdentityProofRequired,
+        isIdentityProofEnabled,
         connect,
         disconnect,
-        authenticate,
-        getActiveSession,
-        listSessions,
-        setActiveSession,
-        removeSession,
-        getAllProfiles,
-        switchSession,
-        getSessionById,
-        getSessionByActor,
-        getAuthStatus,
+        requestIdentityProof,
+        listStoredSessions,
+        switchToSession,
+        addTxError,
     ]);
     return (_jsx(XPRNContext.Provider, { value: providerValue, children: children }));
 };