@rockerone/xprnkit 0.3.5 → 0.3.7

package/build/providers/XPRNProvider.d.ts

@@ -9,7 +9,8 @@ import { type IdentityProofStatus } from "../services/identity-proof";
  */
 export type XPRNIdentityProof = {
     actor: string;
-    publicKey: string;
+    /** Public key (optional - not available for browser/WebAuth wallets) */
+    publicKey?: string;
     /** JWT token from the identity proof verification */
     token?: string;
     /** Additional data from the verification response */

package/build/providers/XPRNProvider.js

@@ -61,6 +61,9 @@ export const XPRNProvider = ({ children, config, }) => {
     const isRestoringRef = useRef(false);
     const isAuthenticatingRef = useRef(false);
     const isSwitchingSessionRef = useRef(false);
+    const sessionRef = useRef(null);
+    // Keep sessionRef in sync with session state
+    sessionRef.current = session;
     // List stored sessions from proton-web-sdk localStorage
     const listStoredSessions = useCallback(() => {
         return sessionStorage.getLinkList(config.requesterAccount);
@@ -103,7 +106,6 @@ export const XPRNProvider = ({ children, config, }) => {
                         const newToken = result.token || storedEntry.identityProofToken;
                         setIdentityProof({
                             actor: actor,
-                            publicKey: "",
                             token: newToken,
                         });
                         setIdentityProofStatus("success");
@@ -237,7 +239,9 @@ export const XPRNProvider = ({ children, config, }) => {
         errorsStackRef.current.push(parseTransactionErrorMessage(message));
     }, []);
     const requestIdentityProof = useCallback(async (success, fail) => {
-        if (!session) {
+        // Use ref to get the latest session value
+        const currentSession = sessionRef.current;
+        if (!currentSession) {
             fail(new Error("No session available for identity proof"));
             return;
         }
@@ -253,7 +257,7 @@ export const XPRNProvider = ({ children, config, }) => {
         try {
             // Step 1: Sign with wallet
             setIdentityProofStatus("signing");
-            const proof = await createIdentityProof(session);
+            const proof = await createIdentityProof(currentSession);
             // Step 2: Verify with backend
             setIdentityProofStatus("verifying");
             const verifyRes = await verifyIdentityProof(proof, { createUrl: identityProofConfig.createUrl, headers: identityProofConfig.headers });
@@ -268,9 +272,9 @@ export const XPRNProvider = ({ children, config, }) => {
             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();
+                const actor = currentSession.auth.actor.toString();
+                const permission = currentSession.auth.permission.toString();
+                const chainId = currentSession.chainId.toString();
                 sessionStorage.updateIdentityProofToken(config.requesterAccount, { actor, permission }, chainId, verifyRes.token);
             }
             success(identityProofData);
@@ -282,7 +286,7 @@ export const XPRNProvider = ({ children, config, }) => {
         finally {
             isAuthenticatingRef.current = false;
         }
-    }, [session, identityProofConfig, config.requesterAccount]);
+    }, [identityProofConfig, config.requesterAccount]);
     // Legacy alias
     const authenticate = requestIdentityProof;
     // Validate stored token silently
@@ -321,7 +325,6 @@ export const XPRNProvider = ({ children, config, }) => {
                 const newToken = result.token || storedToken;
                 setIdentityProof({
                     actor,
-                    publicKey: "", // We don't have public key from stored token
                     token: newToken,
                 });
                 setIdentityProofStatus("success");
@@ -359,7 +362,8 @@ export const XPRNProvider = ({ children, config, }) => {
         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) {
+        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)) {
@@ -368,8 +372,8 @@ export const XPRNProvider = ({ children, config, }) => {
                 }
             });
         }
-        else if (identityProofConfig.enforceOnConnect) {
-            // No stored token but enforceOnConnect is enabled - trigger auth flow
+        else if (identityProofConfig.enforceOnConnect || identityProofConfig.required) {
+            // No stored token (or no validation URL) but identity proof is required - trigger auth flow
             requestIdentityProof(() => { }, () => { });
         }
     }, [session, identityProof, identityProofConfig, config.requesterAccount, validateStoredToken, requestIdentityProof]);

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

@@ -34,11 +34,11 @@ export async function createIdentityProof(session, options) {
         throw new DOMException("Aborted", "AbortError");
     }
     // Build the identity proof
+    // Note: publicKey may not be available for browser/WebAuth wallets
     const proof = {
         signer: {
             actor,
             permission,
-            publicKey: session.publicKey.toString(),
         },
         transaction: txResult.resolvedTransaction,
         signatures: txResult.signatures.map(sig => sig.toString()),

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

@@ -5,7 +5,8 @@ import type { LinkSession } from "@proton/web-sdk";
 export type IdentityProofSigner = {
     actor: string;
     permission: string;
-    publicKey: string;
+    /** Public key (optional - not available for browser/WebAuth wallets) */
+    publicKey?: string;
 };
 /**
  * Identity proof generated from wallet signing

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

@@ -34,11 +34,12 @@ export async function verifyIdentityProof(proof, config, options) {
     }
     const url = getCreateUrl(config);
     // Build request body
+    // Note: public_key is optional (not available for browser/WebAuth wallets)
     const requestBody = {
         signer: {
             actor: proof.signer.actor,
             permission: proof.signer.permission,
-            public_key: proof.signer.publicKey,
+            ...(proof.signer.publicKey ? { public_key: proof.signer.publicKey } : {}),
         },
         transaction: proof.transaction,
         signatures: proof.signatures,

package/package.json

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