@rockerone/xprnkit 0.3.0

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export * from './providers/XPRNProvider';
+export * from './components';
+export * from './utils';
+export type { Link, LinkSession, ProtonWebLink } from "@proton/web-sdk";
+export type { Api, ApiInterfaces, JsonRpc, JsSignatureProvider } from "@proton/js";

package/build/index.js

@@ -0,0 +1,3 @@
+export * from './providers/XPRNProvider';
+export * from './components';
+export * from './utils';

package/build/interfaces/proton_wrap.d.ts

@@ -0,0 +1,141 @@
+type proton_wrap_Actions = {
+    "deladdress": {
+        index: number;
+    };
+    "deladdress2": {
+        index: number;
+    };
+    "generateauth": {
+        protonAccount: string;
+        time: {};
+    };
+    "saveaddress": {
+        address: {
+            index: number;
+            account: string;
+            coin: string;
+            wallet: string;
+            address: string;
+            address_hash: {};
+        };
+    };
+    "saveaddress2": {
+        address: {
+            index: number;
+            account: string;
+            chain: string;
+            address: string;
+            address_hash: {};
+        };
+    };
+    "wrapfinish": {
+        wrap_hash: {};
+        status: string;
+    };
+    "wrapfinish2": {
+        wrap_hash: {};
+        status: string;
+    };
+    "wrapprocess": {
+        wrap_hash: {};
+    };
+    "wrapprocess2": {
+        wrap_hash: {};
+    };
+    "wrapsetconf": {
+        wrap_hash: {};
+        confirmations: number;
+    };
+    "wrapsetconf2": {
+        wrap_hash: {};
+        confirmations: number;
+    };
+    "wrapstart": {
+        balance: {};
+        txid: string;
+        coin: string;
+        wallet: string;
+        deposit_address: string;
+        confirmations: number;
+    };
+    "wrapstart2": {
+        balance: {};
+        id: string;
+        txid: string;
+        chain: string;
+        deposit_address: string;
+        confirmations: number;
+    };
+};
+export declare const proton_wrap: {
+    deladdress: (authorization: Authorization[], data: proton_wrap_Actions["deladdress"]) => XPRAction<"deladdress">;
+    deladdress2: (authorization: Authorization[], data: proton_wrap_Actions["deladdress2"]) => XPRAction<"deladdress2">;
+    generateauth: (authorization: Authorization[], data: proton_wrap_Actions["generateauth"]) => XPRAction<"generateauth">;
+    saveaddress: (authorization: Authorization[], data: proton_wrap_Actions["saveaddress"]) => XPRAction<"saveaddress">;
+    saveaddress2: (authorization: Authorization[], data: proton_wrap_Actions["saveaddress2"]) => XPRAction<"saveaddress2">;
+    wrapfinish: (authorization: Authorization[], data: proton_wrap_Actions["wrapfinish"]) => XPRAction<"wrapfinish">;
+    wrapfinish2: (authorization: Authorization[], data: proton_wrap_Actions["wrapfinish2"]) => XPRAction<"wrapfinish2">;
+    wrapprocess: (authorization: Authorization[], data: proton_wrap_Actions["wrapprocess"]) => XPRAction<"wrapprocess">;
+    wrapprocess2: (authorization: Authorization[], data: proton_wrap_Actions["wrapprocess2"]) => XPRAction<"wrapprocess2">;
+    wrapsetconf: (authorization: Authorization[], data: proton_wrap_Actions["wrapsetconf"]) => XPRAction<"wrapsetconf">;
+    wrapsetconf2: (authorization: Authorization[], data: proton_wrap_Actions["wrapsetconf2"]) => XPRAction<"wrapsetconf2">;
+    wrapstart: (authorization: Authorization[], data: proton_wrap_Actions["wrapstart"]) => XPRAction<"wrapstart">;
+    wrapstart2: (authorization: Authorization[], data: proton_wrap_Actions["wrapstart2"]) => XPRAction<"wrapstart2">;
+};
+type proton_wrap_Tables = {
+    "Address": {
+        index: number;
+        account: string;
+        coin: string;
+        wallet: string;
+        address: string;
+        address_hash: {};
+    };
+    "Address2": {
+        index: number;
+        account: string;
+        chain: string;
+        address: string;
+        address_hash: {};
+    };
+    "Wrap": {
+        index: number;
+        proton_account: string;
+        balance: {};
+        txid: string;
+        coin: string;
+        wallet: string;
+        deposit_address: string;
+        status: string;
+        confirmations: number;
+        finish_txid: {};
+        wrap_hash: {};
+    };
+    "Wrap2": {
+        index: number;
+        proton_account: string;
+        balance: {};
+        id: string;
+        txid: string;
+        chain: string;
+        deposit_address: string;
+        status: string;
+        confirmations: number;
+        finish_txid: {};
+        wrap_hash: {};
+    };
+};
+export type Authorization = {
+    actor: string;
+    permission: "active" | "owner" | string;
+};
+export type XPRAction<A extends keyof (proton_wrap_Actions)> = {
+    account: 'proton.wrap';
+    name: A;
+    authorization: Authorization[];
+    data: proton_wrap_Actions[A];
+};
+export type Tables<TableName extends keyof (proton_wrap_Tables)> = proton_wrap_Tables[TableName];
+export type Actions<ActionName extends keyof (proton_wrap_Actions)> = proton_wrap_Actions[ActionName];
+export declare function proton_wrap_actionParams<ActionName extends keyof (proton_wrap_Actions)>(actionPrams: proton_wrap_Actions[ActionName]): (object | number | string | number[] | string[])[];
+export {};

package/build/interfaces/proton_wrap.js

@@ -0,0 +1,81 @@
+export const proton_wrap = {
+    deladdress: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'deladdress',
+        authorization,
+        data
+    }),
+    deladdress2: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'deladdress2',
+        authorization,
+        data
+    }),
+    generateauth: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'generateauth',
+        authorization,
+        data
+    }),
+    saveaddress: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'saveaddress',
+        authorization,
+        data
+    }),
+    saveaddress2: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'saveaddress2',
+        authorization,
+        data
+    }),
+    wrapfinish: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapfinish',
+        authorization,
+        data
+    }),
+    wrapfinish2: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapfinish2',
+        authorization,
+        data
+    }),
+    wrapprocess: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapprocess',
+        authorization,
+        data
+    }),
+    wrapprocess2: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapprocess2',
+        authorization,
+        data
+    }),
+    wrapsetconf: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapsetconf',
+        authorization,
+        data
+    }),
+    wrapsetconf2: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapsetconf2',
+        authorization,
+        data
+    }),
+    wrapstart: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapstart',
+        authorization,
+        data
+    }),
+    wrapstart2: (authorization, data) => ({
+        account: 'proton.wrap',
+        name: 'wrapstart2',
+        authorization,
+        data
+    })
+};
+export function proton_wrap_actionParams(actionPrams) { return Object.values(actionPrams); }

package/build/interfaces/service-status.d.ts

@@ -0,0 +1 @@
+export type ServiceStatus = 'idle' | 'pending' | 'success' | 'fail';

package/build/interfaces/service-status.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/transaction-error-message.d.ts

@@ -0,0 +1,5 @@
+export type XPRNTransactionsError = {
+    rawMessage: string;
+    message: string;
+    customErrorCode?: string;
+};

package/build/interfaces/transaction-error-message.js

@@ -0,0 +1 @@
+export {};

package/build/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/build/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/build/providers/XPRNProvider.d.ts

@@ -0,0 +1,59 @@
+import type { Link, LinkSession, ProtonWebLink } from "@proton/web-sdk";
+import React from "react";
+import { JsonRpc } from "@proton/js";
+export type XPRNAuthentication = {
+    actor: string;
+    publicKey: string;
+    data?: any;
+};
+export type XPRNProfile = {
+    displayName: string;
+    avatar?: string;
+    authentication?: XPRNAuthentication;
+    isKyc: boolean;
+};
+export type XPRNSession = {
+    actor: string;
+    session: LinkSession;
+    link: ProtonWebLink | Link;
+    profile: XPRNProfile | null;
+    authentication: XPRNAuthentication | null;
+};
+export type XPRProviderConfig = {
+    chainId: string;
+    endpoints: string[];
+    dAppName: string;
+    requesterAccount: string;
+    requesterLogo?: string;
+    authenticationUrl?: string;
+    enforceAuthentication?: boolean;
+    apiMode: "testnet" | "mainnet";
+    restoreSession?: boolean;
+};
+type XPRNProviderProps = {
+    children: React.ReactNode | React.ReactNode[];
+    config: XPRProviderConfig;
+};
+type XPRNProviderContext = {
+    session: LinkSession | null;
+    link: ProtonWebLink | null;
+    profile: XPRNProfile | null;
+    rpc: JsonRpc | null;
+    txErrorsStack: null;
+    authentication: XPRNAuthentication | null;
+    authenticate: (success: (res: any) => void, fail: (e: any) => void, actor?: string) => void;
+    addTransactionError: (rawMessage: string) => void;
+    connect: (restore?: boolean, silent?: boolean, onSession?: (session: LinkSession) => void, onProfile?: (profile: XPRNProfile) => void) => void;
+    disconnect: (actor?: string) => void;
+    getActiveSession: () => XPRNSession | null;
+    listSessions: () => XPRNSession[];
+    setActiveSession: (actor: string) => void;
+    removeSession: (actor: string) => Promise<void>;
+    getAllProfiles: () => XPRNProfile[];
+    switchSession: (actor: string) => void;
+    getSessionById: (actor: string) => XPRNSession | null;
+    getSessionByActor: (actor: string) => XPRNSession | null;
+};
+export declare const XPRNProvider: React.FunctionComponent<XPRNProviderProps>;
+export declare function useXPRN(): XPRNProviderContext;
+export {};

package/build/providers/XPRNProvider.js

@@ -0,0 +1,336 @@
+"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 { parseTransactionErrorMessage } from "../utils";
+import { proton_wrap } from "../interfaces/proton_wrap";
+const XPRNContext = React.createContext({
+    session: null,
+    link: null,
+    profile: null,
+    rpc: null,
+    txErrorsStack: null,
+    connect: () => { },
+    disconnect: () => { },
+    addTransactionError(rawMessage) { },
+    authentication: null,
+    authenticate: () => { },
+    getActiveSession: () => null,
+    listSessions: () => [],
+    setActiveSession: () => { },
+    removeSession: async () => { },
+    getAllProfiles: () => [],
+    switchSession: () => { },
+    getSessionById: () => null,
+    getSessionByActor: () => null,
+});
+export const XPRNProvider = ({ children, config, }) => {
+    // Multi-session state management
+    const [sessions, setSessions] = useState(new Map());
+    const [activeSessionId, setActiveSessionId] = useState(null);
+    // Keep for backward compatibility and other features
+    const [jsonRpc, setJsonPrc] = useState(new JsonRpc(config.endpoints));
+    const [errorsStack, setErrorStack] = useState();
+    const onSessionRef = useRef();
+    const onProfileRef = useRef();
+    // Computed values from active session for backward compatibility
+    const activeSession = activeSessionId ? sessions.get(activeSessionId) : null;
+    const session = activeSession?.session || null;
+    const link = activeSession?.link || null;
+    const profile = activeSession?.profile || null;
+    const authentication = activeSession?.authentication || null;
+    // Session management methods
+    const getActiveSession = useCallback(() => {
+        return activeSession || null;
+    }, [activeSession]);
+    const listSessions = useCallback(() => {
+        return Array.from(sessions.values());
+    }, [sessions]);
+    const setActiveSession = useCallback((actor) => {
+        if (sessions.has(actor)) {
+            setActiveSessionId(actor);
+            // Store in localStorage for persistence
+            if (typeof window !== "undefined") {
+                localStorage.setItem("xprn_active_session_actor", actor);
+            }
+        }
+        else {
+            console.warn(`Session with actor ${actor} not found`);
+        }
+    }, [sessions]);
+    const switchSession = useCallback((actor) => {
+        setActiveSession(actor);
+    }, [setActiveSession]);
+    const getSessionById = useCallback((actor) => {
+        return sessions.get(actor) || null;
+    }, [sessions]);
+    const getSessionByActor = useCallback((actor) => {
+        return sessions.get(actor) || null;
+    }, [sessions]);
+    const removeSession = useCallback(async (actor) => {
+        const sessionToRemove = sessions.get(actor);
+        if (!sessionToRemove) {
+            console.warn(`Session with actor ${actor} not found`);
+            return;
+        }
+        // Remove session from the link
+        try {
+            await sessionToRemove.link.removeSession(config.requesterAccount, sessionToRemove.session.auth, sessionToRemove.session.chainId);
+        }
+        catch (e) {
+            console.error("Error removing session from link:", e);
+        }
+        // Remove from sessions map
+        setSessions(prev => {
+            const newSessions = new Map(prev);
+            newSessions.delete(actor);
+            return newSessions;
+        });
+        // If this was the active session, clear it
+        if (activeSessionId === actor) {
+            setActiveSessionId(null);
+            if (typeof window !== "undefined") {
+                localStorage.removeItem("xprn_active_session_actor");
+            }
+        }
+    }, [sessions, activeSessionId, config]);
+    const getAllProfiles = useCallback(() => {
+        return Array.from(sessions.values())
+            .map(s => s.profile)
+            .filter((p) => p !== null);
+    }, [sessions]);
+    const connect = useCallback((restoreSession, onSession, onProfile) => {
+        console.log("restoreSession", restoreSession);
+        ConnectWallet({
+            linkOptions: {
+                endpoints: config.endpoints,
+                restoreSession: restoreSession || false,
+            },
+            selectorOptions: {
+                appName: config.dAppName,
+            },
+            transportOptions: {
+                requestAccount: config.requesterAccount,
+            },
+        }).then(res => {
+            onSessionRef.current = onSession;
+            onProfileRef.current = onProfile;
+            if (res.link && res.session) {
+                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 and set as active
+                setSessions(prev => {
+                    const newSessions = new Map(prev);
+                    newSessions.set(actor, newSession);
+                    return newSessions;
+                });
+                // Auto-switch to newly connected session
+                setActiveSessionId(actor);
+                if (typeof window !== "undefined") {
+                    localStorage.setItem("xprn_active_session_actor", actor);
+                }
+                // Fetch profile data
+                const api = new ApiClass(config.apiMode && config.apiMode == "testnet"
+                    ? "proton-test"
+                    : "proton");
+                api.getProtonAvatar(actor).then(profileRes => {
+                    if (profileRes) {
+                        const xprProfile = {
+                            displayName: profileRes.name,
+                            avatar: `${profileRes.avatar}`,
+                            isKyc: profileRes.kyc.length > 0 || false,
+                        };
+                        // Update session with profile
+                        setSessions(prev => {
+                            const newSessions = new Map(prev);
+                            const existingSession = newSessions.get(actor);
+                            if (existingSession) {
+                                newSessions.set(actor, {
+                                    ...existingSession,
+                                    profile: xprProfile,
+                                });
+                            }
+                            return newSessions;
+                        });
+                    }
+                });
+            }
+        });
+    }, [config]);
+    const disconnect = useCallback(async (actor) => {
+        // If actor is provided, disconnect that specific session
+        // Otherwise, disconnect the active session
+        const targetActor = actor || activeSessionId;
+        if (!targetActor) {
+            console.warn("No session to disconnect");
+            return;
+        }
+        await removeSession(targetActor);
+    }, [activeSessionId, removeSession]);
+    const addTxError = useCallback((message) => {
+        const mutatedMessages = errorsStack && errorsStack.length >= 0 ? [...errorsStack] : [];
+        mutatedMessages.push(parseTransactionErrorMessage(message));
+        setErrorStack(mutatedMessages);
+    }, [errorsStack, setErrorStack]);
+    const authenticate = useCallback((success, fail, actor) => {
+        // Use provided actor or active session
+        const targetActor = actor || activeSessionId;
+        if (!targetActor) {
+            fail(new Error("No session available for authentication"));
+            return;
+        }
+        const targetSession = sessions.get(targetActor);
+        if (!targetSession) {
+            fail(new Error(`Session not found for actor: ${targetActor}`));
+            return;
+        }
+        if (!config.authenticationUrl) {
+            fail(new Error("Authentication URL not configured"));
+            return;
+        }
+        const authenticationAction = proton_wrap.generateauth([
+            {
+                actor: targetSession.session.auth.actor.toString(),
+                permission: targetSession.session.auth.permission.toString(),
+            },
+        ], {
+            protonAccount: targetSession.session.auth.actor.toString(),
+            time: new Date().toISOString().slice(0, -1),
+        });
+        try {
+            targetSession.session
+                .transact({ actions: [authenticationAction] }, { broadcast: false })
+                .then(res => {
+                const identityProofBody = {
+                    signer: {
+                        actor: targetSession.session.auth.actor,
+                        permission: targetSession.session.auth.permission,
+                        public_key: targetSession.session.publicKey,
+                    },
+                    transaction: res.resolvedTransaction,
+                    signatures: res.signatures,
+                };
+                if (config.authenticationUrl)
+                    fetch(config.authenticationUrl, {
+                        method: "post",
+                        body: JSON.stringify(identityProofBody),
+                    })
+                        .then(res => res.json())
+                        .then(authRes => {
+                        const authData = {
+                            publicKey: targetSession.session.publicKey.toString(),
+                            actor: targetSession.session.auth.actor.toString(),
+                            data: authRes,
+                        };
+                        // Update session with authentication data
+                        setSessions(prev => {
+                            const newSessions = new Map(prev);
+                            const existingSession = newSessions.get(targetActor);
+                            if (existingSession) {
+                                newSessions.set(targetActor, {
+                                    ...existingSession,
+                                    authentication: authData,
+                                });
+                            }
+                            return newSessions;
+                        });
+                        success(authRes);
+                    })
+                        .catch(fail);
+            })
+                .catch(fail);
+        }
+        catch (e) {
+            fail(e);
+        }
+    }, [activeSessionId, sessions, config]);
+    // Handle authentication for active session
+    useEffect(() => {
+        if (session && activeSessionId) {
+            const currentSession = sessions.get(activeSessionId);
+            if (currentSession && !currentSession.authentication) {
+                if (config.enforceAuthentication && config.authenticationUrl) {
+                    authenticate(() => { }, () => { });
+                }
+            }
+        }
+        if (session && onSessionRef.current) {
+            onSessionRef.current(session);
+            onSessionRef.current = undefined; // Reset the ref
+        }
+    }, [session, activeSessionId, sessions, authenticate, config]);
+    // Handle profile callbacks
+    useEffect(() => {
+        if (profile && onProfileRef.current) {
+            onProfileRef.current(profile);
+            onProfileRef.current = undefined; // Reset the ref
+        }
+    }, [profile]);
+    // Session restoration - only restore active session
+    useEffect(() => {
+        if (sessions.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) {
+                    // Try to restore the session
+                    connect(true);
+                }
+            }
+        }
+    }, [sessions.size, config.restoreSession, connect]);
+    const providerValue = useMemo(() => {
+        return {
+            // Backward compatibility - active session values
+            session,
+            link,
+            profile,
+            rpc: jsonRpc,
+            addTransactionError: addTxError,
+            connect,
+            disconnect,
+            authenticate,
+            authentication,
+            // Multi-session management methods
+            getActiveSession,
+            listSessions,
+            setActiveSession,
+            removeSession,
+            getAllProfiles,
+            switchSession,
+            getSessionById,
+            getSessionByActor,
+        };
+    }, [
+        session,
+        link,
+        profile,
+        jsonRpc,
+        addTxError,
+        connect,
+        disconnect,
+        authenticate,
+        authentication,
+        getActiveSession,
+        listSessions,
+        setActiveSession,
+        removeSession,
+        getAllProfiles,
+        switchSession,
+        getSessionById,
+        getSessionByActor,
+    ]);
+    return (_jsx(XPRNContext.Provider, { value: providerValue, children: children }));
+};
+export function useXPRN() {
+    return useContext(XPRNContext);
+}

package/build/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './token-precision';
+export * from './transaction-errors';

package/build/utils/index.js

@@ -0,0 +1,2 @@
+export * from './token-precision';
+export * from './transaction-errors';

package/build/utils/token-precision.d.ts

@@ -0,0 +1 @@
+export declare function toPrecision(value: number, precision: number, mode?: 'ceil' | 'floor' | 'round' | 'none', forceDecimal?: boolean): string;

package/build/utils/token-precision.js

@@ -0,0 +1,22 @@
+export function toPrecision(value, precision, mode = 'ceil', forceDecimal = true) {
+    const multiplier = Math.pow(10, precision);
+    let powValue = value * multiplier;
+    switch (mode) {
+        case 'ceil':
+            powValue = Math.ceil(powValue);
+            break;
+        case 'floor':
+            powValue = Math.floor(powValue);
+            break;
+        case 'round':
+            powValue = Math.round(powValue);
+            break;
+        case 'none':
+            powValue = Math.ceil(powValue);
+            break;
+    }
+    const mutatedValue = powValue / multiplier;
+    if (forceDecimal)
+        return mutatedValue.toFixed(precision);
+    return mutatedValue.toString();
+}