@rockerone/xprnkit 0.4.2 → 0.4.4

package/README.md

@@ -98,10 +98,12 @@ function YourComponent() {
     profile,
     identityProof,
     identityProofStatus,
+    identityProofError,
     connect,
     disconnect,
     pushTransaction,
     switchToSession,
+    requestIdentityProof,
   } = useXPRN();
 
   // Use the context values and functions
@@ -120,6 +122,7 @@ The `useXPRN` hook returns an object with the following properties:
 - `profile`: `XPRNKitProfile | null` - Profile data for the active session.
 - `identityProof`: `XPRNKitIdentityProof | null` - Identity proof for the active session (when identity proof is configured).
 - `identityProofStatus`: `XPRNKitIdentityProofStatus` - Current status of the identity proof process (`"idle"` | `"signing"` | `"verifying"` | `"validating"` | `"success"` | `"expired"` | `"error"`).
+- `identityProofError`: `Error | null` - The error from the last failed identity proof attempt, or `null` when there is no error.
 
 #### Methods
 
@@ -127,6 +130,7 @@ The `useXPRN` hook returns an object with the following properties:
 - `disconnect()`: Disconnects the current active session.
 - `pushTransaction(actions: any[])`: Pushes a transaction with the given actions using the active session.
 - `switchToSession(actor: string, permission: string)`: Switches to a different stored session by restoring it from the Proton Web SDK storage.
+- `requestIdentityProof()`: Triggers the identity proof flow (restore, sign, authenticate) for the current session. Can be used to retry after an error or to request proof on demand when `identityProof.required` is `false`.
 
 ### Basic Example
 
@@ -229,6 +233,8 @@ type XPRNKitIdentityProofConfig = {
 3. If no valid proof exists, the user is prompted to sign a message in their wallet.
 4. The signed message is sent to the `createUrl` backend endpoint for verification.
 5. The backend returns a JWT token which is stored in localStorage and made available via `useXPRN().identityProof`.
+6. If any step fails, `identityProofStatus` is set to `"error"` and the error is available via `useXPRN().identityProofError`.
+7. You can call `requestIdentityProof()` to retry after a failure, or to trigger proof on demand when `required` is `false`.
 
 ## Backend Endpoints
 
@@ -280,14 +286,21 @@ Validates an existing JWT token:
 Use `XPRNIdentityProofGate` to conditionally render content based on identity proof status:
 
 ```tsx
-import { XPRNIdentityProofGate } from '@rockerone/xprnkit';
+import { XPRNIdentityProofGate, useXPRN } from '@rockerone/xprnkit';
 
 function ProtectedContent() {
+  const { identityProofError, requestIdentityProof } = useXPRN();
+
   return (
     <XPRNIdentityProofGate
       fallback={<p>Please verify your identity to access this content.</p>}
       loading={<p>Verifying identity...</p>}
-      error={<p>Verification failed. Please try again.</p>}
+      error={
+        <div>
+          <p>Verification failed: {identityProofError?.message}</p>
+          <button onClick={requestIdentityProof}>Retry</button>
+        </div>
+      }
       notConnected={<p>Please connect your wallet first.</p>}
     >
       <p>This content is only visible after identity verification.</p>

package/build/interfaces/identity-proof.d.ts

@@ -13,6 +13,9 @@ export type XPRNKitIdentityProof = {
         permission: string;
     };
     token: string;
+    metadata: {
+        [key: string]: any;
+    };
 };
 export type XPRNKitIdentityProofConfig = {
     required: boolean;

package/build/providers/xprnkit-provider.d.ts

@@ -13,10 +13,12 @@ type XPRNProviderContext = {
     profile: XPRNKitProfile | null;
     identityProof: XPRNKitIdentityProof | null;
     identityProofStatus: XPRNKitIdentityProofStatus;
+    identityProofError: Error | null;
     connect: (restore?: boolean) => void;
     disconnect: () => Promise<void>;
     pushTransaction: (actions: any[]) => Promise<void>;
     switchToSession: (actor: string, permission: string) => Promise<void>;
+    requestIdentityProof: () => Promise<void>;
 };
 export declare const XPRNProvider: React.FunctionComponent<XPRNProviderProps>;
 export declare function useXPRN(): XPRNProviderContext;

package/build/providers/xprnkit-provider.js

@@ -14,10 +14,12 @@ const XPRNContext = React.createContext({
     profile: null,
     identityProof: null,
     identityProofStatus: "idle",
+    identityProofError: null,
     connect: () => { },
     disconnect: async () => { },
     pushTransaction: async () => { },
     switchToSession: async () => { },
+    requestIdentityProof: async () => { },
 });
 export const XPRNProvider = ({ children, config, }) => {
     const [session, setSession] = useState(null);
@@ -25,6 +27,7 @@ export const XPRNProvider = ({ children, config, }) => {
     const [profile, setProfile] = useState(null);
     const [identityProof, setIdentityProof] = useState(null);
     const [identityProofStatus, setIdentityProofStatus] = useState("idle");
+    const [identityProofError, setIdentityProofError] = useState(null);
     const profileStorage = new XPRNKitProfileStorage();
     const identityProofStorage = new XPRNKitIdentityStorage();
     async function fetchProfile(session) {
@@ -144,6 +147,35 @@ export const XPRNProvider = ({ children, config, }) => {
             }
         });
     }
+    async function processIdentityProof(session) {
+        if (!config.identityProof)
+            return;
+        try {
+            setIdentityProofError(null);
+            setIdentityProofStatus("verifying");
+            const existingIdentityProof = await restoreIdentityProof(session).catch(() => null);
+            if (existingIdentityProof) {
+                setIdentityProof(existingIdentityProof);
+                setIdentityProofStatus("success");
+                return;
+            }
+            setIdentityProofStatus("signing");
+            const identityProofPayload = await createIdentityProof(session);
+            setIdentityProofStatus("verifying");
+            const proof = await fetchIdentityProof(identityProofPayload, session);
+            setIdentityProof(proof);
+            setIdentityProofStatus("success");
+        }
+        catch (error) {
+            setIdentityProofStatus("error");
+            setIdentityProofError(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    const requestIdentityProof_ = useCallback(async () => {
+        if (!session)
+            return;
+        await processIdentityProof(session);
+    }, [session, config]);
     const connect = useCallback(async (restore) => {
         const { session, link } = await ConnectWallet({
             linkOptions: {
@@ -167,24 +199,7 @@ export const XPRNProvider = ({ children, config, }) => {
         setLink(link);
         await fetchProfile(session);
         if (config.identityProof && config.identityProof.required) {
-            console.log('verifying identity proof');
-            setIdentityProofStatus("verifying");
-            const existingIdentityProof = await restoreIdentityProof(session).catch(() => {
-                console.log('Identity proof not found, creating new one through catch');
-            });
-            console.log('existingIdentityProof', existingIdentityProof);
-            if (!existingIdentityProof) {
-                console.log('creating identity proof');
-                const identityProofPayload = await createIdentityProof(session);
-                const identityProof = await fetchIdentityProof(identityProofPayload, session);
-                setIdentityProof(identityProof);
-                setIdentityProofStatus("success");
-            }
-            else {
-                console.log('restoring identity proof');
-                setIdentityProof(existingIdentityProof);
-                setIdentityProofStatus("success");
-            }
+            await processIdentityProof(session);
         }
     }, [config]);
     const disconnect = useCallback(async () => {
@@ -217,7 +232,7 @@ export const XPRNProvider = ({ children, config, }) => {
         if (!session)
             connect(true);
     }, []);
-    return (_jsx(XPRNContext.Provider, { value: { config, session, link, profile, identityProof, identityProofStatus, connect, disconnect, pushTransaction, switchToSession }, children: children }));
+    return (_jsx(XPRNContext.Provider, { value: { config, session, link, profile, identityProof, identityProofStatus, identityProofError, connect, disconnect, pushTransaction, switchToSession, requestIdentityProof: requestIdentityProof_ }, children: children }));
 };
 export function useXPRN() {
     return useContext(XPRNContext);

package/package.json

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