@rockerone/xprnkit 0.3.8 → 0.3.10

package/build/components/identity/xprn-identity-proof-gate.d.ts

@@ -5,7 +5,7 @@ type XPRNIdentityProofGateProps = {
      */
     children: React.ReactNode;
     /**
-     * Content to render when identity proof is required but not yet obtained.
+     * Content to render when identity proof is not obtained.
      * If not provided, renders nothing.
      */
     fallback?: React.ReactNode;
@@ -24,11 +24,6 @@ type XPRNIdentityProofGateProps = {
      * If not provided, uses fallback.
      */
     notConnected?: React.ReactNode;
-    /**
-     * If true, only gates when identityProof.required is true in config.
-     * If false (default), gates whenever identity proof is configured.
-     */
-    onlyWhenRequired?: boolean;
 };
 /**
  * Conditionally renders children based on identity proof status.
@@ -51,9 +46,7 @@ export declare const XPRNIdentityProofGate: React.FunctionComponent<XPRNIdentity
  * Hook to check identity proof gate status
  * Returns the same information used by XPRNIdentityProofGate
  */
-export declare function useIdentityProofGate(options?: {
-    onlyWhenRequired?: boolean;
-}): {
+export declare function useIdentityProofGate(): {
     isGateActive: boolean;
     isConnected: boolean;
     isInProgress: boolean;

package/build/components/identity/xprn-identity-proof-gate.js

@@ -17,16 +17,12 @@ import { useXPRN } from "../../providers/XPRNProvider";
  * </XPRNIdentityProofGate>
  * ```
  */
-export const XPRNIdentityProofGate = ({ children, fallback = null, loading, error, notConnected, onlyWhenRequired = false, }) => {
-    const { session, identityProof, identityProofStatus, isIdentityProofEnabled, isIdentityProofRequired, } = useXPRN();
+export const XPRNIdentityProofGate = ({ children, fallback = null, loading, error, notConnected, }) => {
+    const { session, identityProof, identityProofStatus, isIdentityProofEnabled, } = useXPRN();
     // If identity proof is not enabled, render children directly
     if (!isIdentityProofEnabled) {
         return _jsx(_Fragment, { children: children });
     }
-    // If onlyWhenRequired is true and identity proof is not required, render children
-    if (onlyWhenRequired && !isIdentityProofRequired) {
-        return _jsx(_Fragment, { children: children });
-    }
     // No session connected
     if (!session) {
         return _jsx(_Fragment, { children: notConnected ?? fallback });
@@ -51,26 +47,25 @@ XPRNIdentityProofGate.displayName = "XPRNIdentityProofGate";
  * Hook to check identity proof gate status
  * Returns the same information used by XPRNIdentityProofGate
  */
-export function useIdentityProofGate(options) {
-    const { session, identityProof, identityProofStatus, isIdentityProofEnabled, isIdentityProofRequired, needsIdentityProof, requestIdentityProof, } = useXPRN();
-    const onlyWhenRequired = options?.onlyWhenRequired ?? false;
-    // Determine if gating should be active
-    const isGateActive = isIdentityProofEnabled && (!onlyWhenRequired || isIdentityProofRequired);
+export function useIdentityProofGate() {
+    const { session, identityProof, identityProofStatus, isIdentityProofEnabled, requestIdentityProof, } = useXPRN();
     // Determine current state
     const isConnected = session !== null;
     const isInProgress = identityProofStatus === "signing" || identityProofStatus === "verifying" || identityProofStatus === "validating";
     const hasError = identityProofStatus === "error" || identityProofStatus === "expired";
     const isVerified = identityProof !== null;
     // Should render protected content?
-    const shouldRenderChildren = !isGateActive || isVerified;
+    const shouldRenderChildren = !isIdentityProofEnabled || isVerified;
+    // Needs identity proof: enabled, connected, and not yet verified
+    const needsIdentityProof = isIdentityProofEnabled && isConnected && !isVerified;
     return {
-        isGateActive,
+        isGateActive: isIdentityProofEnabled,
         isConnected,
         isInProgress,
         hasError,
         isVerified,
         shouldRenderChildren,
-        needsIdentityProof: isGateActive && needsIdentityProof,
+        needsIdentityProof,
         requestIdentityProof,
         identityProofStatus,
     };

package/build/components/identity/xprn-session-name.js

@@ -7,7 +7,7 @@ import { useXPRN } from "../../providers/XPRNProvider";
  * Get badge styling based on identity proof status
  */
 function useIdentityProofBadgeStyle() {
-    const { identityProofStatus, isIdentityProofEnabled, needsIdentityProof } = useXPRN();
+    const { identityProofStatus, isIdentityProofEnabled, identityProof, session } = useXPRN();
     return useMemo(() => {
         if (!isIdentityProofEnabled) {
             return { visible: false, className: "" };
@@ -18,6 +18,7 @@ function useIdentityProofBadgeStyle() {
         const isSuccess = identityProofStatus === "success";
         const isError = identityProofStatus === "error" || identityProofStatus === "expired";
         const isIdle = identityProofStatus === "idle";
+        const needsIdentityProof = session !== null && identityProof === null;
         // Build className based on status
         let className = "";
         if (isPending) {
@@ -42,12 +43,12 @@ function useIdentityProofBadgeStyle() {
             isSuccess,
             isError,
         };
-    }, [identityProofStatus, isIdentityProofEnabled, needsIdentityProof]);
+    }, [identityProofStatus, isIdentityProofEnabled, identityProof, session]);
 }
-export const XPRNSessionName = ({ children, className, }) => {
-    const { profile, session, config } = useXPRN();
+export const XPRNSessionName = ({ children, className, showIdentityProof = false, }) => {
+    const { profile, session } = useXPRN();
     const badgeStyle = useIdentityProofBadgeStyle();
-    const showBadge = (config?.identityProof?.required || config?.identityProof?.enforceOnConnect) && badgeStyle.visible;
+    const showBadge = showIdentityProof && badgeStyle.visible;
     const rootClasses = classNames({
         "flex gap-2 items-center justify-center": true,
         [`${className}`]: className,

package/build/providers/XPRNProvider.d.ts

@@ -35,12 +35,8 @@ export type XPRNIdentityProofConfig = {
     validationUrl?: string;
     /** Time in seconds before expiration to trigger validation (default: 300) */
     validationBuffer?: number;
-    /** Automatically authenticate on connect (default: false) */
-    enforceOnConnect?: boolean;
     /** Automatically re-authenticate when token expires (default: false) */
     autoReauthenticate?: boolean;
-    /** Require identity proof for the app (default: false) */
-    required?: boolean;
     /** Additional headers for identity proof requests */
     headers?: Record<string, string>;
     /** Request timeout in milliseconds */
@@ -58,8 +54,6 @@ export type XPRProviderConfig = {
     identityProof?: XPRNIdentityProofConfig;
     /** @deprecated Use identityProof.createUrl instead */
     authenticationUrl?: string;
-    /** @deprecated Use identityProof.enforceOnConnect instead */
-    enforceAuthentication?: boolean;
 };
 type XPRNProviderProps = {
     children: React.ReactNode | React.ReactNode[];
@@ -73,13 +67,9 @@ type XPRNProviderContext = {
     rpc: JsonRpc | null;
     identityProof: XPRNIdentityProof | null;
     identityProofStatus: IdentityProofStatus;
-    /** True if identity proof is configured but not yet obtained for current session */
-    needsIdentityProof: boolean;
-    /** True if identity proof is configured with required=true */
-    isIdentityProofRequired: boolean;
     /** True if identity proof is enabled (config.identityProof is defined) */
     isIdentityProofEnabled: boolean;
-    connect: (restore?: boolean, onSession?: (session: LinkSession, link: ProtonWebLink | Link) => void, onProfile?: (profile: XPRNProfile) => void) => void;
+    connect: (restore?: boolean, onSession?: (session: LinkSession, link: ProtonWebLink | Link) => void, onProfile?: (profile: XPRNProfile) => void, onIdentityProof?: (proof: XPRNIdentityProof) => void, onIdentityProofError?: (error: Error) => void) => void;
     disconnect: () => Promise<void>;
     requestIdentityProof: (success: (res: XPRNIdentityProof) => void, fail: (e: any) => void) => void;
     listStoredSessions: () => StoredSessionRef[];

package/build/providers/XPRNProvider.js

@@ -14,8 +14,6 @@ const XPRNContext = React.createContext({
     rpc: null,
     identityProof: null,
     identityProofStatus: "idle",
-    needsIdentityProof: false,
-    isIdentityProofRequired: false,
     isIdentityProofEnabled: false,
     connect: () => { },
     disconnect: async () => { },
@@ -44,26 +42,29 @@ export const XPRNProvider = ({ children, config, }) => {
         if (config.authenticationUrl) {
             return {
                 createUrl: config.authenticationUrl,
-                enforceOnConnect: config.enforceAuthentication,
             };
         }
         return null;
-    }, [config.identityProof, config.authenticationUrl, config.enforceAuthentication]);
-    // Helper booleans
+    }, [config.identityProof, config.authenticationUrl]);
+    // Helper boolean
     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 onIdentityProofRef = useRef();
+    const onIdentityProofErrorRef = useRef();
     const isRestoringRef = useRef(false);
     const isAuthenticatingRef = useRef(false);
     const isSwitchingSessionRef = useRef(false);
     const sessionRef = useRef(null);
-    // Keep sessionRef in sync with session state
+    const linkRef = useRef(null);
+    // Queue for pending callbacks when requestIdentityProof is called while already in progress
+    const pendingCallbacksRef = useRef([]);
+    // Keep refs in sync with state
     sessionRef.current = session;
+    linkRef.current = link;
     // List stored sessions from proton-web-sdk localStorage
     const listStoredSessions = useCallback(() => {
         return sessionStorage.getLinkList(config.requesterAccount);
@@ -162,7 +163,7 @@ export const XPRNProvider = ({ children, config, }) => {
         // Mark session switch as complete
         isSwitchingSessionRef.current = false;
     }, [link, config.requesterAccount, config.apiMode, identityProofConfig]);
-    const connect = useCallback((restoreSession, onSession, onProfile) => {
+    const connect = useCallback((restoreSession, onSession, onProfile, onIdentityProof, onIdentityProofError) => {
         ConnectWallet({
             linkOptions: {
                 endpoints: config.endpoints,
@@ -177,6 +178,8 @@ export const XPRNProvider = ({ children, config, }) => {
         }).then(res => {
             onSessionRef.current = onSession;
             onProfileRef.current = onProfile;
+            onIdentityProofRef.current = onIdentityProof;
+            onIdentityProofErrorRef.current = onIdentityProofError;
             if (res.link && res.session) {
                 // Update state with new session
                 setLink(res.link);
@@ -218,12 +221,15 @@ export const XPRNProvider = ({ children, config, }) => {
         });
     }, [config]);
     const disconnect = useCallback(async () => {
-        if (!session || !link) {
+        // Use refs to get latest values (avoid stale closure issues)
+        const currentSession = sessionRef.current;
+        const currentLink = linkRef.current;
+        if (!currentSession || !currentLink) {
             console.warn("No session to disconnect");
             return;
         }
         try {
-            await link.removeSession(config.requesterAccount, session.auth, session.chainId);
+            await currentLink.removeSession(config.requesterAccount, currentSession.auth, currentSession.chainId);
         }
         catch (e) {
             console.error("Error removing session:", e);
@@ -234,7 +240,7 @@ export const XPRNProvider = ({ children, config, }) => {
         setIdentityProof(null);
         setIdentityProofStatus("idle");
         // Note: Keep link reference for potential session switching
-    }, [session, link, config.requesterAccount]);
+    }, [config.requesterAccount]);
     const addTxError = useCallback((message) => {
         errorsStackRef.current.push(parseTransactionErrorMessage(message));
     }, []);
@@ -249,8 +255,9 @@ export const XPRNProvider = ({ children, config, }) => {
             fail(new Error("Identity proof not configured"));
             return;
         }
+        // Idempotent: if already in progress, queue callbacks to be called when complete
         if (isAuthenticatingRef.current) {
-            fail(new Error("Identity proof already in progress"));
+            pendingCallbacksRef.current.push({ success, fail });
             return;
         }
         isAuthenticatingRef.current = true;
@@ -278,10 +285,30 @@ export const XPRNProvider = ({ children, config, }) => {
                 sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor, permission }, chainId, verifyRes.token);
             }
             success(identityProofData);
+            // Call connect-level callback if registered
+            if (onIdentityProofRef.current) {
+                onIdentityProofRef.current(identityProofData);
+            }
+            // Call all queued callbacks with success
+            const pendingCallbacks = pendingCallbacksRef.current;
+            pendingCallbacksRef.current = [];
+            for (const cb of pendingCallbacks) {
+                cb.success(identityProofData);
+            }
         }
         catch (error) {
             setIdentityProofStatus("error");
             fail(error);
+            // Call connect-level error callback if registered
+            if (onIdentityProofErrorRef.current) {
+                onIdentityProofErrorRef.current(error instanceof Error ? error : new Error(String(error)));
+            }
+            // Call all queued callbacks with error
+            const pendingCallbacks = pendingCallbacksRef.current;
+            pendingCallbacksRef.current = [];
+            for (const cb of pendingCallbacks) {
+                cb.fail(error);
+            }
         }
         finally {
             isAuthenticatingRef.current = false;
@@ -347,7 +374,7 @@ export const XPRNProvider = ({ children, config, }) => {
             return false;
         }
     }, [identityProofConfig, config.requesterAccount]);
-    // Handle token restoration and auto-authentication when session is established
+    // Handle token restoration when session is established (no auto-authentication)
     // Note: This effect is skipped when switchToSession is handling the identity proof state
     useEffect(() => {
         // Skip if we're in the middle of a session switch (switchToSession handles this)
@@ -355,28 +382,19 @@ export const XPRNProvider = ({ children, config, }) => {
             return;
         if (!session || identityProof)
             return;
-        if (!identityProofConfig)
+        if (!identityProofConfig?.validationUrl)
             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
+        // Check if there's a stored token and try to validate it silently
         const storedEntry = sessionStorage.get(config.requesterAccount, { actor, permission }, chainId);
         const hasStoredToken = storedEntry?.identityProofToken && typeof storedEntry.identityProofToken === 'string' && storedEntry.identityProofToken.length > 0;
-        if (hasStoredToken && identityProofConfig.validationUrl) {
-            // 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 || identityProofConfig.required) {
-            // No stored token (or no validation URL) but identity proof is required - trigger auth flow
-            requestIdentityProof(() => { }, () => { });
+        if (hasStoredToken) {
+            // Try to validate stored token silently - dev handles the result via callbacks
+            validateStoredToken(actor, permission, chainId);
         }
-    }, [session, identityProof, identityProofConfig, config.requesterAccount, validateStoredToken, requestIdentityProof]);
+    }, [session, identityProof, identityProofConfig, config.requesterAccount, validateStoredToken]);
     // Handle profile callbacks
     useEffect(() => {
         if (profile && onProfileRef.current) {
@@ -405,9 +423,6 @@ export const XPRNProvider = ({ children, config, }) => {
             // Identity proof state
             identityProof,
             identityProofStatus,
-            // Helper booleans
-            needsIdentityProof,
-            isIdentityProofRequired,
             isIdentityProofEnabled,
             // Core methods
             connect,
@@ -430,8 +445,6 @@ export const XPRNProvider = ({ children, config, }) => {
         profile,
         identityProof,
         identityProofStatus,
-        needsIdentityProof,
-        isIdentityProofRequired,
         isIdentityProofEnabled,
         connect,
         disconnect,

package/build/services/identity-proof/create-identity-proof.js

@@ -28,7 +28,15 @@ export async function createIdentityProof(session, options) {
         time: new Date().toISOString().slice(0, -1),
     });
     // Sign the transaction without broadcasting
-    const txResult = await session.transact({ actions: [authenticationAction] }, { broadcast: false });
+    let txResult;
+    try {
+        txResult = await session.transact({ actions: [authenticationAction] }, { broadcast: false });
+    }
+    catch (error) {
+        // Re-throw with clearer context for wallet signing failures
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Wallet signing failed: ${message}`);
+    }
     // Check for abort after wallet interaction
     if (options?.signal?.aborted) {
         throw new DOMException("Aborted", "AbortError");

package/build/services/identity-proof/types.d.ts

@@ -34,12 +34,8 @@ export type IdentityProofConfig = {
     validationUrl?: string;
     /** Time in seconds before expiration to trigger validation (default: 300 = 5 minutes) */
     validationBuffer?: number;
-    /** Automatically authenticate on connect (default: false) */
-    enforceOnConnect?: boolean;
     /** Automatically re-authenticate when token expires (default: false) */
     autoReauthenticate?: boolean;
-    /** Require identity proof for the app - enables helper booleans and gate component (default: false) */
-    required?: boolean;
     /** Additional headers for identity proof requests */
     headers?: Record<string, string>;
     /** Request timeout in milliseconds */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rockerone/xprnkit",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "source": "src/index.ts",
   "main": "build/index.js",
   "type": "module",