@mattrglobal/verifier-sdk-web 2.2.1-unstable.9 → 2.3.0

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

@@ -356,8 +356,29 @@ export declare const CreateSessionResponseValidator: v.UnionSchema<[v.ObjectSche
     readonly sessionId: v.StringSchema<undefined>;
     readonly sessionKey: v.StringSchema<undefined>;
     readonly sessionUrl: v.StringSchema<undefined>;
+    readonly authRequestUri: v.StringSchema<undefined>;
     readonly state: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
 }, undefined>], undefined>;
+/**
+ * The payload passed to the {@link RequestCredentialsOptions.onPresentationRequest} hook for an OpenID4VP session.
+ */
+export type PresentationRequestOpenId4vp = {
+    type: SessionType.Openid4vp;
+    sessionId: string;
+    authRequestUri: string;
+};
+/**
+ * The payload passed to the {@link RequestCredentialsOptions.onPresentationRequest} hook for a Digital Credentials
+ * API session.
+ */
+export type PresentationRequestDigitalCredentialsApi = {
+    type: SessionType.DigitalCredentialsApi;
+    sessionId: string;
+};
+/**
+ * The payload passed to the {@link RequestCredentialsOptions.onPresentationRequest} hook.
+ */
+export type PresentationRequest = PresentationRequestOpenId4vp | PresentationRequestDigitalCredentialsApi;
 export type AbortSessionRequest = v.InferOutput<typeof AbortSessionRequestValidator>;
 export declare const AbortSessionRequestValidator: v.ObjectSchema<{
     readonly sessionId: v.StringSchema<undefined>;

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

@@ -1,17 +1,18 @@
 import * as v from "valibot";
 import { BaseError } from "../../common";
-import { CredentialQuery, Mode, PresentationSessionResult } from "./credential-presentation";
+import { CredentialQuery, Mode, PresentationRequest, PresentationSessionResult } from "./credential-presentation";
 export declare enum LocalStorageKey {
     challenge = "mattr_chg",
     sessionId = "mattr_sid",
     state = "mattr_st"
 }
 export declare const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
-export declare const MATTR_SDK_VERSION_VALUE = "2.2.0";
+export declare const MATTR_SDK_VERSION_VALUE = "2.3.0";
 export declare enum MessageEventDataType {
     PresentationCompleted = "PresentationCompleted",// { type: "PresentationCompleted", responseCode, sessionId }
     PresentationTimeout = "PresentationTimeout",// { type: "PresentationTimeout", sessionId }
-    PresentationAbort = "PresentationAbort"
+    PresentationAbort = "PresentationAbort",// { type: "PresentationAbort", sessionId }
+    PresentationRequestUpdated = "PresentationRequestUpdated"
 }
 export type SameDeviceRequestCredentialsOptions = {
     challenge: string;
@@ -29,6 +30,7 @@ export type CrossDeviceRequestCredentialsOptions = {
     sessionKey: string;
     sessionId: string;
     state?: string;
+    onPresentationRequest?: (request: PresentationRequest) => void | Promise<void>;
 };
 /**
  * Options for openid4vpConfiguration to request credentials via a same-device flow.
@@ -132,6 +134,17 @@ export type RequestCredentialsOptions = {
      * appended as a plain query parameter to the auth request URI.
      */
     state?: string;
+    /**
+     * An optional hook invoked once after presentation session creation, and again every time the OpenID4VP
+     * auth-request URI is regenerated (cross-device QR code refreshes). Not re-invoked beyond the initial call for
+     * same-device or Digital Credentials API sessions.
+     *
+     * If this hook throws or its returned promise rejects, the in-progress presentation is aborted (the session is
+     * aborted server-side and, for cross-device, the iframe is closed) and `requestCredentials()` resolves with an
+     * {@link RequestCredentialsErrorType.OnPresentationRequestFailed} error. To continue the presentation flow
+     * regardless of an error in the hook, catch and handle the error inside the hook.
+     */
+    onPresentationRequest?: (request: PresentationRequest) => void | Promise<void>;
 };
 export declare const RequestCredentialsOptionsValidator: v.ObjectSchema<{
     readonly credentialQuery: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
@@ -171,6 +184,7 @@ export type MessageEvent = {
         type: MessageEventDataType;
         responseCode?: string;
         sessionId?: string;
+        authRequestUri?: string;
     };
     origin: string;
 };
@@ -204,7 +218,8 @@ export type RequestCredentialsResponse = {
 export declare enum RequestCredentialsErrorType {
     RequestCredentialsFailed = "RequestCredentialsFailed",
     Timeout = "Timeout",
-    Abort = "Abort"
+    Abort = "Abort",
+    OnPresentationRequestFailed = "OnPresentationRequestFailed"
 }
 export declare enum RequestCredentialsErrorMessage {
     FailedToGetSessionResult = "Failed to get session result",
@@ -216,7 +231,8 @@ export declare enum RequestCredentialsErrorMessage {
     DcApiResponseParseError = "Failed to parse response from Digital Credentials API",
     Abort = "User aborted the session",
     Timeout = "User session timeout",
-    StateMismatch = "State mismatch between requested session and back-channel result"
+    StateMismatch = "State mismatch between requested session and back-channel result",
+    OnPresentationRequestFailed = "The onPresentationRequest hook threw an error or rejected"
 }
 /**
  * The error type for the `abortCredentialRequest` function

package/dist/verifier-js.development.js

@@ -7,8 +7,8 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2026-06-19
- * Version: 2.2.0
+ * Generated: 2026-08-17
+ * Version: 2.3.0
  * Dependencies:
  *
  * neverthrow -- 4.3.0
@@ -1370,6 +1370,7 @@
         sessionId: string(),
         sessionKey: string(),
         sessionUrl: string(),
+        authRequestUri: string(),
         state: optional(string())
     });
     const CreateSessionResponseValidator = union([ CreateSessionDigitalCredentialsValidator, CreateSessionOpenId4vpResponseValidator ]);
@@ -1386,12 +1387,13 @@
         LocalStorageKey["state"] = "mattr_st";
     })(LocalStorageKey || (LocalStorageKey = {}));
     const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
-    const MATTR_SDK_VERSION_VALUE = "2.2.0";
+    const MATTR_SDK_VERSION_VALUE = "2.3.0";
     var MessageEventDataType;
     (function(MessageEventDataType) {
         MessageEventDataType["PresentationCompleted"] = "PresentationCompleted";
         MessageEventDataType["PresentationTimeout"] = "PresentationTimeout";
         MessageEventDataType["PresentationAbort"] = "PresentationAbort";
+        MessageEventDataType["PresentationRequestUpdated"] = "PresentationRequestUpdated";
     })(MessageEventDataType || (MessageEventDataType = {}));
     const OpenId4vpConfigSameDeviceOptionsValidator = object({
         walletProviderId: optional(string()),
@@ -1418,6 +1420,7 @@
         RequestCredentialsErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
         RequestCredentialsErrorType["Timeout"] = "Timeout";
         RequestCredentialsErrorType["Abort"] = "Abort";
+        RequestCredentialsErrorType["OnPresentationRequestFailed"] = "OnPresentationRequestFailed";
     })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
     var RequestCredentialsErrorMessage;
     (function(RequestCredentialsErrorMessage) {
@@ -1431,6 +1434,7 @@
         RequestCredentialsErrorMessage["Abort"] = "User aborted the session";
         RequestCredentialsErrorMessage["Timeout"] = "User session timeout";
         RequestCredentialsErrorMessage["StateMismatch"] = "State mismatch between requested session and back-channel result";
+        RequestCredentialsErrorMessage["OnPresentationRequestFailed"] = "The onPresentationRequest hook threw an error or rejected";
     })(RequestCredentialsErrorMessage || (RequestCredentialsErrorMessage = {}));
     exports.AbortSessionErrorType = void 0;
     (function(AbortSessionErrorType) {
@@ -1691,7 +1695,7 @@
             body: JSON.stringify(postData)
         });
         const responseResult = await withRetrySafeFetch(fetchResultFn, {
-            retries: 2,
+            retries: 4,
             retryHttpStatus: 404
         });
         if (responseResult.isErr()) {
@@ -1732,71 +1736,111 @@
         }
         removeWindowMessageEventListener();
     };
-    const receiveMessageHandler = options => async event => {
-        const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge, state: state} = options;
-        if (event.origin !== apiBaseUrl) {
-            return;
-        }
-        if (event.data.type === MessageEventDataType.PresentationCompleted && event.data.responseCode && event.data.sessionId) {
-            const responseCode = event.data.responseCode;
-            const result = await exchangeSessionResult({
-                challenge: challenge,
-                responseCode: responseCode,
-                sessionId: sessionId,
-                apiBaseUrl: apiBaseUrl
-            });
-            if (result.isErr()) {
+    const receiveMessageHandler = options => {
+        let queue = Promise.resolve();
+        const processEvent = async event => {
+            const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, sessionKey: sessionKey, apiBaseUrl: apiBaseUrl, challenge: challenge, state: state, onPresentationRequest: onPresentationRequest, isSettled: isSettled} = options;
+            if (isSettled() || event.origin !== apiBaseUrl) {
+                return;
+            }
+            if (event.data.type === MessageEventDataType.PresentationRequestUpdated && event.data.authRequestUri) {
+                if (onPresentationRequest) {
+                    try {
+                        await onPresentationRequest({
+                            type: SessionType.Openid4vp,
+                            sessionId: sessionId,
+                            authRequestUri: event.data.authRequestUri
+                        });
+                    } catch (cause) {
+                        if (isSettled()) {
+                            return;
+                        }
+                        onFailure({
+                            type: exports.RequestCredentialsErrorType.OnPresentationRequestFailed,
+                            message: RequestCredentialsErrorMessage.OnPresentationRequestFailed,
+                            cause: cause
+                        });
+                        closeCrossDeviceModal({
+                            container: container
+                        });
+                        await abortSession({
+                            apiBaseUrl: apiBaseUrl,
+                            sessionId: sessionId,
+                            sessionKey: sessionKey
+                        });
+                    }
+                }
+                return;
+            }
+            if (event.data.type === MessageEventDataType.PresentationCompleted && event.data.responseCode && event.data.sessionId) {
+                const responseCode = event.data.responseCode;
+                const result = await exchangeSessionResult({
+                    challenge: challenge,
+                    responseCode: responseCode,
+                    sessionId: sessionId,
+                    apiBaseUrl: apiBaseUrl
+                });
+                if (isSettled()) {
+                    return;
+                }
+                if (result.isErr()) {
+                    onFailure({
+                        type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                        message: RequestCredentialsErrorMessage.FailedToGetSessionResult
+                    });
+                    closeCrossDeviceModal({
+                        container: container
+                    });
+                    return;
+                }
+                const resultState = "challenge" in result.value ? result.value.state : undefined;
+                if (state !== undefined && resultState !== undefined && state !== resultState) {
+                    onFailure({
+                        type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                        message: RequestCredentialsErrorMessage.StateMismatch
+                    });
+                    closeCrossDeviceModal({
+                        container: container
+                    });
+                    return;
+                }
+                onComplete({
+                    result: "challenge" in result.value ? result.value : undefined,
+                    sessionId: result.value.sessionId,
+                    sessionCompletedInRedirect: false,
+                    state: resultState !== null && resultState !== void 0 ? resultState : state
+                });
+                closeCrossDeviceModal({
+                    container: container
+                });
+                return;
+            }
+            if (event.data.type === MessageEventDataType.PresentationTimeout) {
                 onFailure({
-                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                    message: RequestCredentialsErrorMessage.FailedToGetSessionResult
+                    type: exports.RequestCredentialsErrorType.Timeout,
+                    message: RequestCredentialsErrorMessage.Timeout
                 });
                 closeCrossDeviceModal({
                     container: container
                 });
                 return;
             }
-            const resultState = "challenge" in result.value ? result.value.state : undefined;
-            if (state !== undefined && resultState !== undefined && state !== resultState) {
+            if (event.data.type === MessageEventDataType.PresentationAbort) {
                 onFailure({
-                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                    message: RequestCredentialsErrorMessage.StateMismatch
+                    type: exports.RequestCredentialsErrorType.Abort,
+                    message: RequestCredentialsErrorMessage.Abort
                 });
                 closeCrossDeviceModal({
                     container: container
                 });
                 return;
             }
-            onComplete({
-                result: "challenge" in result.value ? result.value : undefined,
-                sessionId: result.value.sessionId,
-                sessionCompletedInRedirect: false,
-                state: resultState !== null && resultState !== void 0 ? resultState : state
-            });
-            closeCrossDeviceModal({
-                container: container
-            });
-            return;
-        }
-        if (event.data.type === MessageEventDataType.PresentationTimeout) {
-            onFailure({
-                type: exports.RequestCredentialsErrorType.Timeout,
-                message: RequestCredentialsErrorMessage.Timeout
-            });
-            closeCrossDeviceModal({
-                container: container
-            });
-            return;
-        }
-        if (event.data.type === MessageEventDataType.PresentationAbort) {
-            onFailure({
-                type: exports.RequestCredentialsErrorType.Abort,
-                message: RequestCredentialsErrorMessage.Abort
-            });
-            closeCrossDeviceModal({
-                container: container
-            });
-            return;
-        }
+        };
+        return event => {
+            const next = queue.then((() => processEvent(event)));
+            queue = next.catch((() => undefined));
+            return next;
+        };
     };
     const openCrossDeviceModal = options => {
         const {sessionUrl: sessionUrl} = options;
@@ -1814,16 +1858,18 @@
         return modalContainer;
     };
     const requestCredentialsWithCrossDevice = async options => {
-        const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey, state: state} = options;
+        const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey, state: state, onPresentationRequest: onPresentationRequest} = options;
         const container = openCrossDeviceModal({
             sessionUrl: sessionUrl
         });
+        let settled = false;
         return await new Promise((resolve => {
             const abortController = setActiveSession({
                 sessionId: sessionId,
                 sessionKey: sessionKey
             });
             abortController.signal.addEventListener("abort", (() => {
+                settled = true;
                 closeCrossDeviceModal({
                     container: container
                 });
@@ -1836,11 +1882,20 @@
             listener = receiveMessageHandler({
                 container: container,
                 sessionId: sessionId,
+                sessionKey: sessionKey,
                 apiBaseUrl: apiBaseUrl,
                 challenge: challenge,
                 state: state,
-                onComplete: data => resolve(ok(data)),
-                onFailure: error => resolve(err(error))
+                onPresentationRequest: onPresentationRequest,
+                isSettled: () => settled,
+                onComplete: data => {
+                    settled = true;
+                    resolve(ok(data));
+                },
+                onFailure: error => {
+                    settled = true;
+                    resolve(err(error));
+                }
             });
             window.addEventListener(WindowEventListenerType.message, listener, false);
         }));
@@ -2074,7 +2129,7 @@
         }
         assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
         const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initializeOptions;
-        const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration, state: state} = options;
+        const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration, state: state, onPresentationRequest: onPresentationRequest} = options;
         const dcApiSupported = isDigitalCredentialsApiSupported();
         const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
         const createSessionResult = await createSession({
@@ -2096,6 +2151,30 @@
         }
         const session = createSessionResult.value;
         const {sessionKey: sessionKey, sessionId: sessionId} = session;
+        if (onPresentationRequest) {
+            const presentationRequest = session.type === SessionType.DigitalCredentialsApi ? {
+                type: SessionType.DigitalCredentialsApi,
+                sessionId: sessionId
+            } : {
+                type: SessionType.Openid4vp,
+                sessionId: sessionId,
+                authRequestUri: session.authRequestUri
+            };
+            try {
+                await onPresentationRequest(presentationRequest);
+            } catch (cause) {
+                await abortSession({
+                    apiBaseUrl: apiBaseUrl,
+                    sessionId: sessionId,
+                    sessionKey: sessionKey
+                });
+                return err({
+                    type: exports.RequestCredentialsErrorType.OnPresentationRequestFailed,
+                    message: RequestCredentialsErrorMessage.OnPresentationRequestFailed,
+                    cause: cause
+                });
+            }
+        }
         if (session.type === SessionType.DigitalCredentialsApi) {
             const {request: request, sessionTtl: sessionTtl} = session;
             return await requestCredentialsWithDigitalCredentialsApi({
@@ -2131,7 +2210,8 @@
             sessionUrl: sessionUrl,
             sessionKey: sessionKey,
             sessionId: sessionId,
-            state: state
+            state: state,
+            onPresentationRequest: onPresentationRequest
         });
     };
     const deriveOpenId4vpRedirectUri = openid4vpConfiguration => {