@mattrglobal/verifier-sdk-web 1.1.1-unstable.91 → 1.1.1-unstable.94

package/dist/typings/common/safeFetch.d.ts

@@ -16,7 +16,9 @@ export declare enum SafeFetchErrorType {
      */
     UnknownError = "UnknownError"
 }
-export type SafeFetchValidateRespondError = BaseError<SafeFetchErrorType | SafeFetchCommonRespondErrorType.UnexpectedRespond>;
+export type SafeFetchValidateRespondError = BaseError<SafeFetchErrorType | SafeFetchCommonRespondErrorType.UnexpectedRespond> & {
+    status?: number;
+};
 export type SafeFetchError = BaseError<SafeFetchErrorType> & {
     status?: number;
 };

package/dist/typings/common/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/typings/index.d.ts

@@ -1,11 +1,10 @@
-import { initialise, requestCredentials, handleRedirectCallback } from "./verifier";
+import { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest } from "./verifier";
 import { HandleRedirectCallbackError, HandleRedirectCallbackErrorType } from "./verifier/handleRedirectCallback";
-import { CrossDeviceCallbackError, CrossDeviceCallbackErrorType } from "./verifier/requestCredentialsCrossDevice";
-import { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, SameDeviceRequestCredentialsResponse, CrossDeviceRequestCredentialsResponse, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat, CrossDeviceCallback, CrossDeviceCallbackOnCompleteResponse } from "./verifier/types";
-export { Mode, OpenidPresentationCredentialProfileSupported, MobileCredentialVerificationReasonType, RequestCredentialsErrorType, CrossDeviceCallbackErrorType, HandleRedirectCallbackErrorType, CredentialBrandingImageFormat, ClaimType, MobileCredentialResponseErrorCode, };
-export type { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, SameDeviceRequestCredentialsResponse, CrossDeviceRequestCredentialsResponse, RequestCredentialsError, CrossDeviceCallbackError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, CrossDeviceCallback, CrossDeviceCallbackOnCompleteResponse, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
+import { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, AbortSessionErrorType, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat } from "./verifier/types";
+export { Mode, OpenidPresentationCredentialProfileSupported, MobileCredentialVerificationReasonType, RequestCredentialsErrorType, AbortSessionErrorType, HandleRedirectCallbackErrorType, CredentialBrandingImageFormat, ClaimType, MobileCredentialResponseErrorCode, };
+export type { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, RequestCredentialsError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
 declare const utils: {
     generateChallenge: () => string;
     unwrap: <T = unknown>(result: import("neverthrow").Result<T, unknown>, errMessage?: string) => T;
 };
-export { initialise, requestCredentials, handleRedirectCallback, utils };
+export { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest, utils };

package/dist/typings/verifier/abortCredentialRequest.d.ts

@@ -0,0 +1,6 @@
+import { Result } from "neverthrow";
+import { AbortSessionError } from "./types";
+/**
+ * Abort the current credential request if there is an active session.
+ */
+export declare const abortCredentialRequest: () => Promise<Result<void, AbortSessionError>>;

package/dist/typings/verifier/handleRedirectCallback.d.ts

@@ -10,7 +10,7 @@ export declare enum HandleRedirectCallbackErrorType {
 export declare enum HandleRedirectCallbackErrorMessage {
     FailedToFindResponseCode = "Failed to find response code",
     FailedToFindChallenge = "Failed to find challenge",
-    FailedToFindSessionId = "Failed to find sessionId",
+    FailedToFindActiveSession = "Failed to find active session",
     FailedToGetSessionResult = "Failed to get session result"
 }
 export type HandleRedirectCallbackError = BaseError<HandleRedirectCallbackErrorType>;

package/dist/typings/verifier/index.d.ts

@@ -1,5 +1,6 @@
 export { initialise } from "./initialise";
 export { requestCredentials } from "./requestCredentials";
 export { handleRedirectCallback } from "./handleRedirectCallback";
+export { abortCredentialRequest } from "./abortCredentialRequest";
 export * as types from "./types";
 export * as utils from "./utils";

package/dist/typings/verifier/instanceContext.d.ts

@@ -0,0 +1,7 @@
+import { CreatePresentationSession, StoredPresentationSession } from "./types";
+/**
+ * Returns the currently active presentation session.
+ */
+export declare const getActiveSession: () => StoredPresentationSession | undefined;
+export declare const setActiveSession: (session: CreatePresentationSession) => AbortController;
+export declare const removeActiveSession: () => void;

package/dist/typings/verifier/requestCredentialsCrossDevice.d.ts

@@ -1,48 +1,4 @@
 import { Result } from "neverthrow";
-import { BaseError } from "../common";
-import { CrossDeviceCallback, CrossDeviceRequestCredentialsOptions, CrossDeviceRequestCredentialsResponse, MessageEvent, RequestCredentialsError, RequestCredentialsErrorType } from "./types";
-/**
- * The error type for the cross device callback
- */
-export declare enum CrossDeviceCallbackErrorType {
-    Timeout = "Timeout",
-    Abort = "Abort",
-    RequestCredentialsFailed = "RequestCredentialsFailed"
-}
-export declare enum CrossDeviceRequestCredentialsErrorMessage {
-    FailedToGetSessionResult = "Failed to get session result",
-    FailedToCreateSession = "Failed to create session",
-    Abort = "User aborted the session",
-    Timeout = "User session timeout"
-}
-/**
- * Cross device callback error
- */
-export type CrossDeviceCallbackError = BaseError<CrossDeviceCallbackErrorType | RequestCredentialsErrorType>;
-type ReceiveMessageHandlerOptions = {
-    crossDeviceCallback: CrossDeviceCallback;
-    sessionId: string;
-    container: HTMLDivElement;
-    apiBaseUrl: string;
-    challenge: string;
-};
-export declare let listener: (event: MessageEvent) => Promise<void>;
-/**
- * usage from iframe:
- *       fetch("/v2/presentations/sessions/sessionId/status").then(function(response) {
- *         response.json().then(function(data) {
- *           if (data.status === "ResultReady") {
- *             const message = { type: "PresentationCompleted", responseCode: "123", sessionId: "sessionId" };
- *             const targetOrigin = "*"; // need to match front-end URL or "*"
- *             window.postMessage(message, targetOrigin);
- *
- * VII hosted session page in the iframe will notify result via window.postMessage with the following messages:
- *   PresentationCompleted = "PresentationCompleted", // { type: "PresentationCompleted", responseCode, sessionId }
- *   PresentationTimeout = "PresentationTimeout", // { type: "PresentationTimeout", sessionId }
- *   PresentationAbort = "PresentationAbort", // { type: "PresentationAbort", sessionId }
- *
- * @param options -
- */
-export declare const receiveMessageHandler: (options: ReceiveMessageHandlerOptions) => (event: MessageEvent) => Promise<void>;
-export declare const requestCredentialsCrossDevice: (options: CrossDeviceRequestCredentialsOptions) => Promise<Result<CrossDeviceRequestCredentialsResponse, RequestCredentialsError>>;
-export {};
+import { CrossDeviceRequestCredentialsOptions, MessageEvent, RequestCredentialsError, RequestCredentialsResponse } from "./types";
+export declare let listener: ((event: MessageEvent) => Promise<void>) | undefined;
+export declare const requestCredentialsCrossDevice: (options: CrossDeviceRequestCredentialsOptions) => Promise<Result<RequestCredentialsResponse, RequestCredentialsError>>;

package/dist/typings/verifier/requestCredentialsSameDevice.d.ts

@@ -1,5 +1,5 @@
 import { Result } from "neverthrow";
-import { RequestCredentialsError, RequestCredentialsResponse, SameDeviceRequestCredentialsOptions } from "./types";
+import { RequestCredentialsError, SameDeviceRequestCredentialsOptions, RequestCredentialsResponse } from "./types";
 export declare enum SameDeviceRequestCredentialsErrorMessage {
     FailedToStoreChallenge = "Failed to store challenge",
     FailedToCreateSession = "Failed to create session"

package/dist/typings/verifier/types/credential-presentation.d.ts

@@ -38,6 +38,15 @@ export type MobileCredentialError = {
 export declare enum OpenidPresentationCredentialProfileSupported {
     MOBILE = "mobile"
 }
+/**
+ * A subset of status code for presentation session
+ */
+export declare enum PresentationStatusCode {
+    AwaitingRequestRetrieval = "AwaitingRequestRetrieval",
+    AwaitingResponse = "AwaitingResponse",
+    ResponseSubmitted = "ResponseSubmitted",
+    ResultReady = "ResultReady"
+}
 export type CredentialQueryClaim = {
     /**
      * `intentToRetain` (Optional): When set to `true`, the holder will be indicated that the verifier intends to retain this claim beyond the verification workflow. Defaults to `false` when not specified.
@@ -259,9 +268,31 @@ export declare const CreateSessionRequestValidator: v.ObjectSchema<{
 }, undefined>;
 export type CreateSessionResponse = {
     sessionId: string;
+    sessionKey: string;
     sessionUrl: string;
 };
 export declare const CreateSessionResponseValidator: v.ObjectSchema<{
     readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
     readonly sessionUrl: v.StringSchema<undefined>;
 }, undefined>;
+export type AbortSessionRequest = v.InferOutput<typeof AbortSessionRequestValidator>;
+export declare const AbortSessionRequestValidator: v.ObjectSchema<{
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
+}, undefined>;
+export type GetSessionStatusRequest = v.InferOutput<typeof GetSessionStatusRequestValidator>;
+export declare const GetSessionStatusRequestValidator: v.ObjectSchema<{
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
+}, undefined>;
+export type GetSessionStatusResponse = {
+    status: string;
+    responseCode?: string;
+};
+export declare const GetSessionStatusResponseValidator: v.UnionSchema<[v.ObjectSchema<{
+    readonly status: v.PicklistSchema<[PresentationStatusCode.ResultReady], undefined>;
+    readonly responseCode: v.OptionalSchema<v.StringSchema<undefined>, never>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.StringSchema<undefined>;
+}, undefined>], undefined>;

package/dist/typings/verifier/types/verifier-web-sdk.d.ts

@@ -1,6 +1,5 @@
 import * as v from "valibot";
 import { BaseError } from "../../common";
-import { CrossDeviceCallbackError } from "../requestCredentialsCrossDevice";
 import { CredentialQuery, PresentationSessionResult } from "./credential-presentation";
 export declare enum LocalStorageKey {
     challenge = "mattr_chg",
@@ -32,30 +31,8 @@ export type SameDeviceRequestCredentialsOptions = {
     walletProviderId?: string;
     initialiseOptions: InitialiseOptions;
 };
-export type CrossDeviceCallbackOnCompleteResponse = {
-    /**
-     *  Contains the result of the presentation session if result is configured to be available in the front channel
-     */
-    result: PresentationSessionResult | {
-        sessionId: string;
-    };
-    sessionId: string;
-};
-export type CrossDeviceCallback = {
-    /**
-     * The function to be executed on completion of the credential request.
-     * @param result
-     */
-    onComplete: (result: CrossDeviceCallbackOnCompleteResponse) => void;
-    /**
-     * The function to be executed on failure of the credential request.
-     * @param error
-     */
-    onFailure: (error: CrossDeviceCallbackError) => void;
-};
 export type CrossDeviceRequestCredentialsOptions = {
     credentialQuery: CredentialQuery[];
-    crossDeviceCallback: CrossDeviceCallback;
     challenge: string;
     walletProviderId?: string;
     mode: Mode.crossDevice;
@@ -118,10 +95,6 @@ export type RequestCredentialsCrossDeviceDeviceOptions = {
      * An array of CredentialQuery objects that specify the credentials to be requested.
      */
     credentialQuery: CredentialQuery[];
-    /**
-     * The callback functions to be executed on success or failure of the credential request in cross device mode.
-     */
-    crossDeviceCallback: CrossDeviceCallback;
     /**
      * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
      */
@@ -154,10 +127,6 @@ export declare const RequestCredentialsCrossDeviceOptionsValidator: v.ObjectSche
         };
         docType: string;
     }[], undefined>]>;
-    readonly crossDeviceCallback: v.ObjectSchema<{
-        readonly onComplete: v.FunctionSchema<undefined>;
-        readonly onFailure: v.FunctionSchema<undefined>;
-    }, undefined>;
     readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
     readonly mode: v.PicklistSchema<[Mode.crossDevice], undefined>;
@@ -170,10 +139,6 @@ export type RequestCredentialsAutoDetectOptions = {
      * An array of CredentialQuery objects that specify the credentials to be requested.
      */
     credentialQuery: CredentialQuery[];
-    /**
-     * The callback functions to be executed on success or failure of the credential request in cross device mode.
-     */
-    crossDeviceCallback: CrossDeviceCallback;
     /**
      *  The URI to which the user will be redirected after the credential request is completed.
      */
@@ -237,20 +202,10 @@ export declare const RequestCredentialsOptionsValidator: v.UnionSchema<[v.Object
         };
         docType: string;
     }[], undefined>]>;
-    readonly crossDeviceCallback: v.ObjectSchema<{
-        readonly onComplete: v.FunctionSchema<undefined>;
-        readonly onFailure: v.FunctionSchema<undefined>;
-    }, undefined>;
     readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
     readonly mode: v.PicklistSchema<[Mode.crossDevice], undefined>;
 }, undefined>, v.GenericSchema<RequestCredentialsAutoDetectOptions, RequestCredentialsAutoDetectOptions, v.BaseIssue<unknown>>], undefined>;
-/**
- * The response from the same device requestCredentials function
- */
-export type SameDeviceRequestCredentialsResponse = {
-    sessionId: string;
-};
 export type MessageEvent = {
     data: {
         type: MessageEventDataType;
@@ -260,25 +215,48 @@ export type MessageEvent = {
     origin: string;
 };
 /**
- * The response from the cross device requestCredentials function
+ * The response from the requestCredentials function
  */
-export type CrossDeviceRequestCredentialsResponse = {
+export type RequestCredentialsResponse = {
+    /**
+     *  Contains the result of the presentation session if result is configured to be available in the front channel
+     */
+    result?: PresentationSessionResult;
     sessionId: string;
+    sessionCompletedInRedirect: boolean;
 };
-/**
- * The response from the requestCredentials function
- */
-export type RequestCredentialsResponse = SameDeviceRequestCredentialsResponse | CrossDeviceRequestCredentialsResponse;
 /**
  * The error type for the requestCredentials function
  */
 export declare enum RequestCredentialsErrorType {
-    RequestCredentialsFailed = "RequestCredentialsFailed"
+    RequestCredentialsFailed = "RequestCredentialsFailed",
+    Timeout = "Timeout",
+    Abort = "Abort"
+}
+export declare enum RequestCredentialsErrorMessage {
+    FailedToGetSessionResult = "Failed to get session result",
+    FailedToGetSessionStatus = "Failed to get session status",
+    FailedToCreateSession = "Failed to create session",
+    Abort = "User aborted the session",
+    Timeout = "User session timeout"
+}
+/**
+ * The error type for the `abortCredentialRequest` function
+ */
+export declare enum AbortSessionErrorType {
+    AbortSessionFailed = "AbortSessionFailed"
+}
+export declare enum AbortSessionErrorMessage {
+    FailedToAbortSession = "Failed to abort session"
 }
 /**
  * The error response from the requestCredentials function
  */
 export type RequestCredentialsError = BaseError<RequestCredentialsErrorType>;
+/**
+ * The error response from the requestCredentials function
+ */
+export type AbortSessionError = BaseError<AbortSessionErrorType>;
 /**
  * The response from the handleRedirectCallback function
  */
@@ -286,9 +264,7 @@ export type HandleRedirectCallbackResponse = {
     /**
      *  Contains the result of the presentation session if result is configured to be available in the front channel
      */
-    result: PresentationSessionResult | {
-        sessionId: string;
-    };
+    result?: PresentationSessionResult;
     sessionId: string;
 };
 /**
@@ -296,9 +272,23 @@ export type HandleRedirectCallbackResponse = {
  */
 export type InitialiseOptions = {
     apiBaseUrl: string;
-    applicationId?: string;
+    applicationId: string;
 };
 export declare const InitialiseOptionsValidator: v.ObjectSchema<{
-    readonly apiBaseUrl: v.StringSchema<undefined>;
-    readonly applicationId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly apiBaseUrl: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Must not be empty">]>;
+    readonly applicationId: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Must not be empty">]>;
 }, undefined>;
+/**
+ * Struct for a presentation session
+ */
+export type CreatePresentationSession = {
+    readonly sessionId: string;
+    readonly sessionKey: string;
+};
+/**
+ * Struct for a stored presentation session
+ */
+export type StoredPresentationSession = {
+    readonly sessionId: string;
+    readonly sessionKey?: string;
+};

package/dist/typings/verifier/utils.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
 import { SafeFetchValidateRespondError } from "../common/safeFetch";
-import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, InitialiseOptions } from "./types";
+import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitialiseOptions } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -22,11 +22,27 @@ export declare const getHashParamValue: (hash: string, param: string) => string
  * @param challenge - The challenge for the session.
  * @param redirectUri - The redirect URI for the session.
  * @param apiBaseUrl - The base URL of the API.
- * @param applicationId - optional, The ID of the verifier application, if not provided the default application ID will be used.
+ * @param applicationId - The ID of the verifier application.
  * @param walletProviderId - optional, The ID of the wallet provider, if not provided the default wallet provider will be used.
  * @returns A promise that resolves to a result containing either the created session response or an error.
  */
 export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, applicationId, walletProviderId, }: CreateSessionRequest & InitialiseOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateRespondError>>;
+/**
+ * Abort a session with the provided parameters.
+ *
+ * @param sessionId - The unique identifier for the session.
+ * @param sessionKey - The authorization key for performing operations for the session.
+ * @returns A promise that resolves to a ok result when succeed or an error.
+ */
+export declare const abortSession: ({ apiBaseUrl, sessionId, sessionKey, }: AbortSessionRequest & InitialiseOptions) => Promise<Result<void, SafeFetchValidateRespondError>>;
+/**
+ * Retrieve the status for a session with the provided parameters.
+ *
+ * @param sessionId - The unique identifier for the session.
+ * @param sessionKey - The authorization key for performing operations for the session.
+ * @returns A promise that resolves to a result containing either the session status response or an error.
+ */
+export declare const getSessionStatus: ({ apiBaseUrl, sessionId, sessionKey, }: GetSessionStatusRequest & InitialiseOptions) => Promise<Result<GetSessionStatusResponse, SafeFetchValidateRespondError>>;
 /**
  * Exchange the result of a session using the provided parameters.
  *