@rockerone/xprnkit 0.3.12 → 0.4.0

package/build/providers/xprnkit-provider.js

@@ -0,0 +1,224 @@
+"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, useState } from "react";
+import { authenticateIdentityProof, requestIdentityProof, verfiyIdentityProof } from "../services/identity-proof";
+import { getIdentityProofStorageKey, XPRNKitIdentityStorage } from "../utils/identity-proof-storage";
+import { getProfileStorageKey, XPRNKitProfileStorage } from "../utils/profile-storage";
+import { XPRNKIT_STORAGE_PREFIX, XPRNKitLinkStorage } from "../utils/xprnkit-storage";
+const XPRNContext = React.createContext({
+    config: null,
+    session: null,
+    link: null,
+    profile: null,
+    identityProof: null,
+    identityProofStatus: "idle",
+    connect: () => { },
+    disconnect: async () => { },
+    pushTransaction: async () => { },
+    switchToSession: async () => { },
+});
+export const XPRNProvider = ({ children, config, }) => {
+    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");
+    const profileStorage = new XPRNKitProfileStorage();
+    const identityProofStorage = new XPRNKitIdentityStorage();
+    async function fetchProfile(session) {
+        return new Promise(async (resolve, reject) => {
+            if (!session) {
+                reject(new Error('No session'));
+                return;
+            }
+            try {
+                const api = new ApiClass(config.apiMode === "testnet" ? "proton-test" : "proton");
+                api.getProtonAvatar(session.auth.actor.toString()).then(profileRes => {
+                    const profile = {
+                        displayName: profileRes?.name || '',
+                        avatar: profileRes?.avatar || '',
+                        isKyc: profileRes?.kyc ? profileRes.kyc.length > 0 : false,
+                    };
+                    const profileStorageKey = getProfileStorageKey(session.auth.actor.toString(), session.auth.permission.toString(), session.chainId.toString());
+                    profileStorage.write(profileStorageKey, JSON.stringify({
+                        auth: {
+                            actor: session.auth.actor.toString(),
+                            permission: session.auth.permission.toString(),
+                        },
+                        chainId: session.chainId.toString(),
+                        profile: profile
+                    }));
+                    setProfile(profile);
+                    resolve(profile);
+                });
+            }
+            catch (error) {
+                console.error('Error fetching profile:', error);
+                reject(error);
+            }
+        });
+    }
+    async function createIdentityProof(session) {
+        console.log('creating identity proof');
+        return new Promise(async (resolve, reject) => {
+            if (!session) {
+                reject(new Error('No session'));
+                return;
+            }
+            if (!config.identityProof) {
+                reject(new Error('No identity proof config'));
+                return;
+            }
+            try {
+                const identityProofPayload = await requestIdentityProof(session);
+                resolve(identityProofPayload);
+            }
+            catch (error) {
+                console.error('Error creating identity proof:', error);
+                reject(error);
+            }
+        });
+    }
+    async function fetchIdentityProof(identityProofPayload, session) {
+        return new Promise(async (resolve, reject) => {
+            if (!session) {
+                reject(new Error('No session'));
+                return;
+            }
+            if (!config.identityProof) {
+                reject(new Error('No identity proof config'));
+                return;
+            }
+            try {
+                const identityProof = await authenticateIdentityProof(identityProofPayload, config.identityProof);
+                const identityStorageKey = getIdentityProofStorageKey(session.auth.actor.toString(), session.auth.permission.toString(), session.chainId.toString());
+                console.log('writing identity proof to storage', identityProof);
+                identityProofStorage.write(identityStorageKey, JSON.stringify(identityProof));
+                resolve(identityProof);
+            }
+            catch (error) {
+                console.error('Error fetching identity proof:', error);
+                reject(error);
+            }
+        });
+    }
+    ;
+    async function restoreIdentityProof(session) {
+        return new Promise(async (resolve, reject) => {
+            if (!session) {
+                reject(new Error('No session'));
+                return;
+            }
+            if (!config.identityProof) {
+                reject(new Error('No identity proof config'));
+                return;
+            }
+            try {
+                const identityStorageKey = getIdentityProofStorageKey(session.auth.actor.toString(), session.auth.permission.toString(), session.chainId.toString());
+                const storedProof = await identityProofStorage.read(identityStorageKey);
+                const identityProof = storedProof ? JSON.parse(storedProof) : null;
+                console.log('identityProof', identityProof);
+                if (identityProof) {
+                    const validationResult = await verfiyIdentityProof(identityProof, config.identityProof);
+                    console.log('validationResult', validationResult);
+                    if (validationResult) {
+                        resolve(identityProof);
+                    }
+                    else {
+                        // Need to remove the identity proof from the storage
+                        identityProofStorage.remove(identityStorageKey);
+                        reject(new Error('No identity proof to restore'));
+                        return;
+                    }
+                }
+                else {
+                    reject(new Error('No identity proof to restore'));
+                    return;
+                }
+            }
+            catch (error) {
+                console.error('Error restoring identity proof:', error);
+                reject(error);
+            }
+        });
+    }
+    const connect = useCallback(async (restore) => {
+        const { session, link } = await ConnectWallet({
+            linkOptions: {
+                endpoints: config.endpoints,
+                restoreSession: restore || false,
+                storage: new XPRNKitLinkStorage(config.requesterAccount),
+                storagePrefix: XPRNKIT_STORAGE_PREFIX
+            },
+            selectorOptions: {
+                appName: config.dAppName,
+            },
+            transportOptions: {
+                requestAccount: config.requesterAccount,
+            },
+        });
+        if (!session)
+            return;
+        if (!link)
+            return;
+        setSession(session);
+        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");
+            }
+        }
+    }, [config]);
+    const disconnect = useCallback(async () => {
+        if (!link) {
+            return;
+        }
+        if (!session) {
+            return;
+        }
+        await link.removeSession(config.requesterAccount, session.auth, session.chainId);
+        setSession(null);
+        setLink(null);
+        setProfile(null);
+    }, [config.requesterAccount, session, link]);
+    const pushTransaction = useCallback(async (actions) => {
+        if (!session) {
+            return;
+        }
+        await session.transact({ actions }, { broadcast: true });
+    }, [session]);
+    const switchToSession = useCallback(async (actor, permission) => {
+        if (!link) {
+            return;
+        }
+        const restoredSession = await link.restoreSession(config.requesterAccount, { actor, permission }, config.chainId);
+        setSession(restoredSession);
+        setProfile(null);
+    }, [config.requesterAccount, config.chainId, link]);
+    useEffect(() => {
+        if (!session)
+            connect(true);
+    }, []);
+    return (_jsx(XPRNContext.Provider, { value: { config, session, link, profile, identityProof, identityProofStatus, connect, disconnect, pushTransaction, switchToSession }, children: children }));
+};
+export function useXPRN() {
+    return useContext(XPRNContext);
+}

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

@@ -0,0 +1,2 @@
+import { XPRNKitIdentityProof, XPRNKitIdentityProofConfig, XPRNKitIdentityProofPayload } from "interfaces/identity-proof";
+export declare function authenticateIdentityProof(payload: XPRNKitIdentityProofPayload, config: XPRNKitIdentityProofConfig, signal?: AbortSignal): Promise<XPRNKitIdentityProof>;

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

@@ -0,0 +1,42 @@
+export async function authenticateIdentityProof(payload, config, signal) {
+    // Check for abort before starting
+    if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+    const url = config.createUrl;
+    // Build request body
+    // Note: public_key is optional (not available for browser/WebAuth wallets)
+    const requestBody = {
+        signer: {
+            actor: payload.signer.actor,
+            permission: payload.signer.permission,
+        },
+        transaction: payload.transaction,
+        signatures: payload.signatures,
+        chainId: payload.chainId,
+    };
+    // Build fetch options
+    const fetchOptions = {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...config.headers,
+        },
+        body: JSON.stringify(requestBody),
+        signal: signal,
+    };
+    // Make the request
+    const response = await fetch(url, fetchOptions);
+    // Check for abort after fetch
+    if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+    // Handle non-OK responses
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        throw new Error(`Authentication failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    // Parse and return response
+    const result = await response.json();
+    return result;
+}

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

@@ -1,10 +1,3 @@
-export type { IdentityProof, IdentityProofConfig, IdentityProofResult, IdentityProofSigner, IdentityProofStatus, LegacyIdentityProofConfig, UseIdentityProofOptions, UseIdentityProofReturn, } from "./types";
-export { createIdentityProof } from "./create-identity-proof";
-export type { CreateIdentityProofOptions } from "./create-identity-proof";
-export { verifyIdentityProof } from "./verify-identity-proof";
-export type { VerifyIdentityProofOptions } from "./verify-identity-proof";
-export { validateIdentityProof } from "./validate-identity-proof";
-export type { ValidateIdentityProofOptions, ValidateIdentityProofResult, } from "./validate-identity-proof";
-export { parseToken, isTokenExpired, shouldValidateToken, getTokenExpiresIn, } from "./token-utils";
-export type { IdentityProofTokenClaims } from "./token-utils";
-export { useIdentityProof } from "./use-identity-proof";
+export * from "./request-identity-proof";
+export * from "./authenticate-identity-proof";
+export * from "./verify-identity-proof";

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

@@ -1,8 +1,3 @@
-// Pure functions
-export { createIdentityProof } from "./create-identity-proof";
-export { verifyIdentityProof } from "./verify-identity-proof";
-export { validateIdentityProof } from "./validate-identity-proof";
-// Token utilities
-export { parseToken, isTokenExpired, shouldValidateToken, getTokenExpiresIn, } from "./token-utils";
-// React hook
-export { useIdentityProof } from "./use-identity-proof";
+export * from "./request-identity-proof";
+export * from "./authenticate-identity-proof";
+export * from "./verify-identity-proof";

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

@@ -0,0 +1,7 @@
+import type { LinkSession } from "@proton/web-sdk";
+import { XPRNKitIdentityProofPayload } from "interfaces/identity-proof";
+export type CreateIdentityProofOptions = {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+};
+export declare function requestIdentityProof(session: LinkSession, options?: CreateIdentityProofOptions): Promise<XPRNKitIdentityProofPayload>;

package/build/services/identity-proof/{create-identity-proof.js → request-identity-proof.js}

@@ -1,25 +1,10 @@
 import { proton_wrap } from "../../interfaces/proton_wrap";
-/**
- * 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 async function createIdentityProof(session, options) {
+export async function requestIdentityProof(session, options) {
     // Check for abort before starting
     if (options?.signal?.aborted) {
         throw new DOMException("Aborted", "AbortError");
     }
+    console.log('requesting identity proof transaction', session);
     const actor = session.auth.actor.toString();
     const permission = session.auth.permission.toString();
     // Generate the authentication action

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

@@ -1,25 +1,8 @@
-import type { IdentityProof, IdentityProofConfig, LegacyIdentityProofConfig } from "./types";
-export type VerifyIdentityProofOptions = {
-    /** AbortSignal for cancellation */
-    signal?: AbortSignal;
-};
 /**
- * Verifies an identity proof by sending it to the authentication backend.
+ * Validate an existing identity proof token with the backend.
  *
- * This is a pure function that handles only the backend verification step.
- * Use `createIdentityProof` first to generate the proof.
- *
- * @param proof - The identity proof from createIdentityProof
- * @param config - Configuration with createUrl (or legacy authenticationUrl)
- * @param options - Optional configuration (abort signal)
- * @returns Promise resolving to the backend response
- *
- * @example
- * ```typescript
- * const proof = await createIdentityProof(session);
- * const response = await verifyIdentityProof(proof, {
- *   createUrl: '/api/auth/verify'
- * });
- * ```
+ * This is used to extend/refresh a token that is approaching expiration
+ * without requiring a new wallet signature.
  */
-export declare function verifyIdentityProof<T = any>(proof: IdentityProof, config: IdentityProofConfig | LegacyIdentityProofConfig, options?: VerifyIdentityProofOptions): Promise<T>;
+import { XPRNKitIdentityProof, XPRNKitIdentityProofConfig } from "interfaces/identity-proof";
+export declare function verfiyIdentityProof(proof: XPRNKitIdentityProof, config: XPRNKitIdentityProofConfig, signal?: AbortSignal): Promise<XPRNKitIdentityProof>;

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

@@ -1,72 +1,62 @@
 /**
- * Get the URL from config (supports both new and legacy config)
- */
-function getCreateUrl(config) {
-    if ("createUrl" in config) {
-        return config.createUrl;
-    }
-    // Legacy config uses authenticationUrl
-    return config.authenticationUrl;
-}
-/**
- * Verifies an identity proof by sending it to the authentication backend.
- *
- * This is a pure function that handles only the backend verification step.
- * Use `createIdentityProof` first to generate the proof.
- *
- * @param proof - The identity proof from createIdentityProof
- * @param config - Configuration with createUrl (or legacy authenticationUrl)
- * @param options - Optional configuration (abort signal)
- * @returns Promise resolving to the backend response
+ * Validate an existing identity proof token with the backend.
  *
- * @example
- * ```typescript
- * const proof = await createIdentityProof(session);
- * const response = await verifyIdentityProof(proof, {
- *   createUrl: '/api/auth/verify'
- * });
- * ```
+ * This is used to extend/refresh a token that is approaching expiration
+ * without requiring a new wallet signature.
  */
-export async function verifyIdentityProof(proof, config, options) {
-    // Check for abort before starting
-    if (options?.signal?.aborted) {
-        throw new DOMException("Aborted", "AbortError");
-    }
-    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,
-            ...(proof.signer.publicKey ? { public_key: proof.signer.publicKey } : {}),
-        },
-        transaction: proof.transaction,
-        signatures: proof.signatures,
-        chainId: proof.chainId,
-    };
-    // Build fetch options
-    const fetchOptions = {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            ...config.headers,
-        },
-        body: JSON.stringify(requestBody),
-        signal: options?.signal,
-    };
-    // Make the request
-    const response = await fetch(url, fetchOptions);
-    // Check for abort after fetch
-    if (options?.signal?.aborted) {
-        throw new DOMException("Aborted", "AbortError");
-    }
-    // Handle non-OK responses
-    if (!response.ok) {
-        const errorText = await response.text().catch(() => "Unknown error");
-        throw new Error(`Authentication failed: ${response.status} ${response.statusText} - ${errorText}`);
-    }
-    // Parse and return response
-    const result = await response.json();
-    return result;
+export async function verfiyIdentityProof(proof, config, signal) {
+    return new Promise(async (resolve, reject) => {
+        const { validationUrl, headers, timeout } = config;
+        // Check for abort before starting
+        if (signal?.aborted) {
+            throw new DOMException("Aborted", "AbortError");
+        }
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = timeout
+            ? setTimeout(() => controller.abort(), timeout)
+            : null;
+        // Link external signal to controller
+        if (signal) {
+            signal.addEventListener("abort", () => controller.abort());
+        }
+        try {
+            const response = await fetch(validationUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${proof.token}`,
+                    ...headers,
+                },
+                body: JSON.stringify({ token: proof.token }),
+                signal: controller.signal,
+            });
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Check for abort after fetch
+            if (signal?.aborted) {
+                throw new DOMException("Aborted", "AbortError");
+            }
+            // Handle response
+            if (response.ok) {
+                const data = await response.json();
+                resolve(proof);
+            }
+            // Non-OK response means invalid
+            const errorText = await response.text().catch(() => "Validation failed");
+            reject(new Error(errorText));
+        }
+        catch (err) {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Re-throw abort errors
+            if (err instanceof Error && err.name === "AbortError") {
+                reject(err);
+            }
+            // Return invalid for other errors
+            reject(new Error(err instanceof Error ? err.message : "Validation request failed"));
+        }
+    });
 }

package/build/utils/identity-proof-storage.d.ts

@@ -0,0 +1,14 @@
+export type IdentityStorageEntry = {
+    auth: {
+        actor: string;
+        permission: string;
+    };
+    chainId: string;
+    identityProofToken: string | null;
+};
+export declare class XPRNKitIdentityStorage {
+    write(key: string, value: string): Promise<void>;
+    read(key: string): Promise<string | null>;
+    remove(key: string): Promise<void>;
+}
+export declare function getIdentityProofStorageKey(actor: string, permission: string, chainId: string): string;

package/build/utils/identity-proof-storage.js

@@ -0,0 +1,33 @@
+import { formatStorageKey } from "./storage-key";
+const XPRNKIT_IDENTITY_STORAGE_PREFIX = "xprnkit-identity-storage";
+export class XPRNKitIdentityStorage {
+    write(key, value) {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_IDENTITY_STORAGE_PREFIX, key);
+            try {
+                localStorage.setItem(storageKey, value);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    read(key) {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_IDENTITY_STORAGE_PREFIX, key);
+            let storedIdentity = localStorage.getItem(storageKey);
+            resolve(storedIdentity ? storedIdentity : null);
+        });
+    }
+    remove(key) {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_IDENTITY_STORAGE_PREFIX, key);
+            localStorage.removeItem(storageKey);
+            resolve();
+        });
+    }
+}
+export function getIdentityProofStorageKey(actor, permission, chainId) {
+    return formatStorageKey(`${actor}@${permission}`, chainId);
+}

package/build/utils/index.d.ts

@@ -1,3 +1,3 @@
 export * from './token-precision';
 export * from './transaction-errors';
-export * from './auth-storage';
+export * from './identity-proof-storage';

package/build/utils/index.js

@@ -1,3 +1,3 @@
 export * from './token-precision';
 export * from './transaction-errors';
-export * from './auth-storage';
+export * from './identity-proof-storage';

package/build/utils/profile-storage.d.ts

@@ -0,0 +1,17 @@
+import { XPRNKitProfile } from "interfaces/profile";
+export declare const XPRNKIT_PROFILE_STORAGE_PREFIX = "xprnkit-profile-storage";
+export type XPRNKitProfileStorageEntry = {
+    auth: {
+        actor: string;
+        permission: string;
+    };
+    chainId: string;
+    profile: XPRNKitProfile;
+};
+export declare class XPRNKitProfileStorage {
+    write(key: string, value: string): Promise<void>;
+    read(key: string): Promise<string | null>;
+    remove(key: string): Promise<void>;
+    list(): Promise<string>;
+}
+export declare function getProfileStorageKey(actor: string, permission: string, chainId: string): string;

package/build/utils/profile-storage.js

@@ -0,0 +1,48 @@
+import { formatStorageKey } from "./storage-key";
+export const XPRNKIT_PROFILE_STORAGE_PREFIX = "xprnkit-profile-storage";
+export class XPRNKitProfileStorage {
+    write(key, value) {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_PROFILE_STORAGE_PREFIX, key);
+            const listStorageKey = formatStorageKey(XPRNKIT_PROFILE_STORAGE_PREFIX, 'list');
+            const list = localStorage.getItem(listStorageKey);
+            console.log('writing profile to storage', value);
+            try {
+                const rawListData = JSON.parse(list || '[]');
+                const newEntry = JSON.parse(value);
+                const listData = rawListData.filter((item) => item.auth.actor !== newEntry.auth.actor || item.auth.permission !== newEntry.auth.permission || item.chainId !== newEntry.chainId);
+                listData.push(newEntry);
+                localStorage.setItem(listStorageKey, JSON.stringify(listData));
+                localStorage.setItem(storageKey, value);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    read(key) {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_PROFILE_STORAGE_PREFIX, key);
+            let storedProfile = localStorage.getItem(storageKey);
+            resolve(storedProfile ? JSON.parse(storedProfile) : null);
+        });
+    }
+    remove(key) {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_PROFILE_STORAGE_PREFIX, key);
+            localStorage.removeItem(storageKey);
+            resolve();
+        });
+    }
+    list() {
+        return new Promise((resolve, reject) => {
+            let storageKey = formatStorageKey(XPRNKIT_PROFILE_STORAGE_PREFIX, 'list');
+            let storedProfile = localStorage.getItem(storageKey);
+            resolve(storedProfile ? storedProfile : '[]');
+        });
+    }
+}
+export function getProfileStorageKey(actor, permission, chainId) {
+    return formatStorageKey(`${actor}@${permission}`, chainId);
+}

package/build/utils/storage-key.d.ts

@@ -0,0 +1 @@
+export declare function formatStorageKey(prefix: string, ...keys: string[]): string;

package/build/utils/storage-key.js

@@ -0,0 +1,3 @@
+export function formatStorageKey(prefix, ...keys) {
+    return `${prefix}-${keys.join('-')}`;
+}

package/build/utils/xprnkit-storage.d.ts

@@ -0,0 +1,9 @@
+import { LinkStorage } from "@proton/link";
+export declare const XPRNKIT_STORAGE_PREFIX = "xprnkit-storage";
+export declare class XPRNKitLinkStorage implements LinkStorage {
+    appIdentifier: string;
+    constructor(appIdentifier: string);
+    write(key: string, value: string): Promise<void>;
+    read(key: string): Promise<string | null>;
+    remove(key: string): Promise<void>;
+}