@rockerone/xprnkit 0.3.12 → 0.4.1

package/build/utils/xprnkit-storage.js

@@ -0,0 +1,23 @@
+import { formatStorageKey } from "./storage-key";
+export const XPRNKIT_STORAGE_PREFIX = "xprnkit-storage";
+export class XPRNKitLinkStorage {
+    appIdentifier;
+    constructor(appIdentifier) {
+        this.appIdentifier = appIdentifier;
+    }
+    write(key, value) {
+        console.log('write to xprnkit-storage', key, value);
+        localStorage.setItem(formatStorageKey(XPRNKIT_STORAGE_PREFIX, this.appIdentifier, key), value);
+        return Promise.resolve();
+    }
+    read(key) {
+        console.log('read from xprnkit-storage', key);
+        const value = localStorage.getItem(formatStorageKey(XPRNKIT_STORAGE_PREFIX, this.appIdentifier, key));
+        return Promise.resolve(value);
+    }
+    remove(key) {
+        console.log('remove from xprnkit-storage', key);
+        localStorage.removeItem(formatStorageKey(XPRNKIT_STORAGE_PREFIX, this.appIdentifier, key));
+        return Promise.resolve();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rockerone/xprnkit",
-  "version": "0.3.12",
+  "version": "0.4.1",
   "source": "src/index.ts",
   "main": "build/index.js",
   "type": "module",
@@ -12,7 +12,8 @@
     "style": "tailwindcss -i ./src/global.css -o ./build/global.css",
     "bundle": "rimraf ./build && microbundle --jsx React.createElement --jsxFragment React.Fragment",
     "dev": "microbundle watch",
-    "types:bc": "bunx abi2ts proton.wrap -r proton_wrap > ./src/interfaces/proton_wrap.ts"
+    "types:bc": "bunx abi2ts proton.wrap -r proton_wrap > ./src/interfaces/proton_wrap.ts",
+    "prepublishOnly": "npm run build"
   },
   "files": [
     "build",

package/build/providers/XPRNProvider.d.ts

@@ -1,96 +0,0 @@
-import type { Link, LinkSession } from "@proton/link";
-import { ProtonWebLink } from "@proton/web-sdk";
-import React from "react";
-import { JsonRpc } from "@proton/js";
-import { type StoredSessionRef } from "../utils";
-import { type IdentityProofStatus } from "../services/identity-proof";
-/**
- * Identity proof data returned from authentication
- * All fields are optional - dev can store whatever they want
- */
-export type XPRNIdentityProof = {
-    actor?: 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 */
-    data?: any;
-    /** Allow any additional fields for custom flows */
-    [key: string]: any;
-};
-/**
- * @deprecated Use XPRNIdentityProof instead
- */
-export type XPRNAuthentication = XPRNIdentityProof;
-export type XPRNProfile = {
-    displayName: string;
-    avatar?: string;
-    isKyc: boolean;
-};
-/**
- * Identity proof configuration (optional feature)
- */
-export type XPRNIdentityProofConfig = {
-    /** URL for creating identity proof (sign + verify) */
-    createUrl: string;
-    /** URL for validating existing tokens (optional) */
-    validationUrl?: string;
-    /** Time in seconds before expiration to trigger validation (default: 300) */
-    validationBuffer?: number;
-    /** Automatically re-authenticate when token expires (default: false) */
-    autoReauthenticate?: boolean;
-    /** Additional headers for identity proof requests */
-    headers?: Record<string, string>;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-};
-export type XPRProviderConfig = {
-    chainId: string;
-    endpoints: string[];
-    dAppName: string;
-    requesterAccount: string;
-    requesterLogo?: string;
-    apiMode: "testnet" | "mainnet";
-    restoreSession?: boolean;
-    /** Identity proof configuration (optional - if not provided, identity proof is disabled) */
-    identityProof?: XPRNIdentityProofConfig;
-    /** @deprecated Use identityProof.createUrl instead */
-    authenticationUrl?: string;
-};
-type XPRNProviderProps = {
-    children: React.ReactNode | React.ReactNode[];
-    config: XPRProviderConfig;
-};
-type XPRNProviderContext = {
-    config: XPRProviderConfig | null;
-    session: LinkSession | null;
-    link: ProtonWebLink | Link | null;
-    profile: XPRNProfile | null;
-    rpc: JsonRpc | null;
-    identityProof: XPRNIdentityProof | null;
-    identityProofStatus: IdentityProofStatus;
-    /** 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, onIdentityProof?: (proof: XPRNIdentityProof) => void, onIdentityProofError?: (error: Error) => void) => void;
-    disconnect: () => Promise<void>;
-    requestIdentityProof: (success: (res: XPRNIdentityProof) => void, fail: (e: any) => void) => void;
-    /** Set identity proof data manually (for custom auth flows) */
-    setIdentityProof: (data: XPRNIdentityProof | null) => void;
-    /** Clear identity proof and reset status to idle */
-    clearIdentityProof: () => void;
-    /** Set identity proof status manually (for custom auth flows) */
-    setIdentityProofStatus: (status: IdentityProofStatus) => void;
-    listStoredSessions: () => StoredSessionRef[];
-    switchToSession: (auth: string, chainId: string) => Promise<void>;
-    addTransactionError: (rawMessage: string) => void;
-    /** @deprecated Use identityProof instead */
-    authentication: XPRNIdentityProof | null;
-    /** @deprecated Use identityProofStatus instead */
-    authStatus: IdentityProofStatus;
-    /** @deprecated Use requestIdentityProof instead */
-    authenticate: (success: (res: any) => void, fail: (e: any) => void) => void;
-};
-export declare const XPRNProvider: React.FunctionComponent<XPRNProviderProps>;
-export declare function useXPRN(): XPRNProviderContext;
-export {};

package/build/providers/XPRNProvider.js

@@ -1,473 +0,0 @@
-"use client";
-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, useRef, useState, } from "react";
-import { JsonRpc } from "@proton/js";
-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,
-    identityProof: null,
-    identityProofStatus: "idle",
-    isIdentityProofEnabled: false,
-    connect: () => { },
-    disconnect: async () => { },
-    requestIdentityProof: () => { },
-    setIdentityProof: () => { },
-    clearIdentityProof: () => { },
-    setIdentityProofStatus: () => { },
-    listStoredSessions: () => [],
-    switchToSession: async () => { },
-    addTransactionError: () => { },
-    // Legacy
-    authentication: null,
-    authStatus: "idle",
-    authenticate: () => { },
-});
-export const XPRNProvider = ({ children, config, }) => {
-    // 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,
-            };
-        }
-        return null;
-    }, [config.identityProof, config.authenticationUrl]);
-    // Helper boolean
-    const isIdentityProofEnabled = identityProofConfig !== 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);
-    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);
-    }, [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,
-                            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");
-            }
-        }
-        else {
-            // No stored token for this session - clear identity proof state
-            setIdentityProof(null);
-            setIdentityProofStatus("idle");
-        }
-        // Fetch profile for new session
-        const api = new ApiClass(config.apiMode === "testnet" ? "proton-test" : "proton");
-        try {
-            const profileRes = await api.getProtonAvatar(actor);
-            if (profileRes) {
-                setProfile({
-                    displayName: profileRes.name,
-                    avatar: profileRes.avatar,
-                    isKyc: profileRes.kyc.length > 0,
-                });
-            }
-        }
-        catch (error) {
-            console.error("Failed to fetch profile after session switch:", error);
-        }
-        // Trigger onSession callback if set
-        if (onSessionRef.current) {
-            onSessionRef.current(restoredSession, link);
-            onSessionRef.current = undefined;
-        }
-        // Mark session switch as complete
-        isSwitchingSessionRef.current = false;
-    }, [link, config.requesterAccount, config.apiMode, identityProofConfig]);
-    const connect = useCallback((restoreSession, onSession, onProfile, onIdentityProof, onIdentityProofError) => {
-        ConnectWallet({
-            linkOptions: {
-                endpoints: config.endpoints,
-                restoreSession: restoreSession || false,
-            },
-            selectorOptions: {
-                appName: config.dAppName,
-            },
-            transportOptions: {
-                requestAccount: config.requesterAccount,
-            },
-        }).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);
-                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();
-                // Trigger onSession callback
-                if (onSession) {
-                    onSession(res.session, res.link);
-                }
-                // Fetch profile data
-                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,
-                        };
-                        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]);
-    const disconnect = useCallback(async () => {
-        // 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 currentLink.removeSession(config.requesterAccount, currentSession.auth, currentSession.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
-    }, [config.requesterAccount]);
-    const addTxError = useCallback((message) => {
-        errorsStackRef.current.push(parseTransactionErrorMessage(message));
-    }, []);
-    const requestIdentityProof = useCallback(async (success, fail) => {
-        // Use ref to get the latest session value
-        const currentSession = sessionRef.current;
-        if (!currentSession) {
-            fail(new Error("No session available for identity proof"));
-            return;
-        }
-        if (!identityProofConfig) {
-            fail(new Error("Identity proof not configured"));
-            return;
-        }
-        // Idempotent: if already in progress, queue callbacks to be called when complete
-        if (isAuthenticatingRef.current) {
-            pendingCallbacksRef.current.push({ success, fail });
-            return;
-        }
-        isAuthenticatingRef.current = true;
-        try {
-            // Step 1: Sign with wallet
-            setIdentityProofStatus("signing");
-            const proof = await createIdentityProof(currentSession);
-            // Step 2: Verify with backend
-            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,
-                token: verifyRes.token,
-                data: verifyRes,
-            };
-            setIdentityProof(identityProofData);
-            setIdentityProofStatus("success");
-            // Save token to storage
-            if (verifyRes.token) {
-                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);
-            // 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;
-        }
-    }, [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,
-                    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;
-            }
-        }
-        catch (error) {
-            console.error("[XPRNProvider] Token validation error:", error);
-            setIdentityProofStatus("error");
-            return false;
-        }
-    }, [identityProofConfig, config.requesterAccount]);
-    // 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)
-        if (isSwitchingSessionRef.current)
-            return;
-        if (!session || identityProof)
-            return;
-        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 silently
-        const storedEntry = sessionStorage.get(config.requesterAccount, { actor, permission }, chainId);
-        const hasStoredToken = storedEntry?.identityProofToken && typeof storedEntry.identityProofToken === 'string' && storedEntry.identityProofToken.length > 0;
-        if (hasStoredToken) {
-            // Try to validate stored token silently - dev handles the result via callbacks
-            validateStoredToken(actor, permission, chainId);
-        }
-    }, [session, identityProof, identityProofConfig, config.requesterAccount, validateStoredToken]);
-    // Handle profile callbacks
-    useEffect(() => {
-        if (profile && onProfileRef.current) {
-            onProfileRef.current(profile);
-            onProfileRef.current = undefined;
-        }
-    }, [profile]);
-    // Session restoration on mount
-    useEffect(() => {
-        if (isRestoringRef.current)
-            return;
-        if (!session && config.restoreSession) {
-            isRestoringRef.current = true;
-            connect(true);
-        }
-    }, [config.restoreSession, connect, session]);
-    // Helper to clear identity proof
-    const clearIdentityProof = useCallback(() => {
-        setIdentityProof(null);
-        setIdentityProofStatus("idle");
-    }, []);
-    const providerValue = useMemo(() => {
-        return {
-            // Config
-            config,
-            // Session state
-            session,
-            link,
-            profile,
-            rpc: jsonRpcRef.current,
-            // Identity proof state
-            identityProof,
-            identityProofStatus,
-            isIdentityProofEnabled,
-            // Core methods
-            connect,
-            disconnect,
-            requestIdentityProof,
-            // Identity proof setters (for custom flows)
-            setIdentityProof,
-            clearIdentityProof,
-            setIdentityProofStatus,
-            // Session switching
-            listStoredSessions,
-            switchToSession,
-            // Utility
-            addTransactionError: addTxError,
-            // Legacy aliases
-            authentication: identityProof,
-            authStatus: identityProofStatus,
-            authenticate: requestIdentityProof,
-        };
-    }, [
-        config,
-        session,
-        link,
-        profile,
-        identityProof,
-        identityProofStatus,
-        isIdentityProofEnabled,
-        connect,
-        disconnect,
-        requestIdentityProof,
-        clearIdentityProof,
-        listStoredSessions,
-        switchToSession,
-        addTxError,
-    ]);
-    return (_jsx(XPRNContext.Provider, { value: providerValue, children: children }));
-};
-export function useXPRN() {
-    return useContext(XPRNContext);
-}

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

@@ -1,23 +0,0 @@
-import type { LinkSession } from "@proton/web-sdk";
-import type { IdentityProof } from "./types";
-export type CreateIdentityProofOptions = {
-    /** AbortSignal for cancellation */
-    signal?: AbortSignal;
-};
-/**
- * Creates an identity proof by signing a generateauth action with the wallet.
- *
- * This is a pure function that handles only the wallet signing step.
- * It does NOT send the proof to any backend - use `verifyIdentityProof` for that.
- *
- * @param session - The LinkSession from the connected wallet
- * @param options - Optional configuration (abort signal)
- * @returns Promise resolving to the signed IdentityProof
- *
- * @example
- * ```typescript
- * const proof = await createIdentityProof(session);
- * // proof contains: { signer, transaction, signatures }
- * ```
- */
-export declare function createIdentityProof(session: LinkSession, options?: CreateIdentityProofOptions): Promise<IdentityProof>;