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

package/dist/verifier-js.development.js

@@ -7,7 +7,7 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2025-02-24
+ * Generated: 2025-02-25
  * Version: 1.1.0
  * Dependencies:
  *
@@ -744,24 +744,6 @@
             }
         };
     }
-    function function_(message) {
-        return {
-            kind: "schema",
-            type: "function",
-            reference: function_,
-            expects: "Function",
-            async: false,
-            message: message,
-            _run: function _run(dataset, config2) {
-                if (typeof dataset.value === "function") {
-                    dataset.typed = true;
-                } else {
-                    _addIssue(this, "type", dataset, config2);
-                }
-                return dataset;
-            }
-        };
-    }
     function object(entries, message) {
         return {
             kind: "schema",
@@ -1302,6 +1284,13 @@
     (function(OpenidPresentationCredentialProfileSupported) {
         OpenidPresentationCredentialProfileSupported["MOBILE"] = "mobile";
     })(exports.OpenidPresentationCredentialProfileSupported || (exports.OpenidPresentationCredentialProfileSupported = {}));
+    var PresentationStatusCode;
+    (function(PresentationStatusCode) {
+        PresentationStatusCode["AwaitingRequestRetrieval"] = "AwaitingRequestRetrieval";
+        PresentationStatusCode["AwaitingResponse"] = "AwaitingResponse";
+        PresentationStatusCode["ResponseSubmitted"] = "ResponseSubmitted";
+        PresentationStatusCode["ResultReady"] = "ResultReady";
+    })(PresentationStatusCode || (PresentationStatusCode = {}));
     const CredentialQueryValidator = object({
         profile: picklist([ exports.OpenidPresentationCredentialProfileSupported.MOBILE ]),
         docType: string(),
@@ -1333,8 +1322,15 @@
     });
     const CreateSessionResponseValidator = object({
         sessionId: string(),
+        sessionKey: string(),
         sessionUrl: string()
     });
+    const GetSessionStatusResponseValidator = union([ object({
+        status: picklist([ PresentationStatusCode.ResultReady ]),
+        responseCode: optional(string())
+    }), object({
+        status: string()
+    }) ]);
     var LocalStorageKey;
     (function(LocalStorageKey) {
         LocalStorageKey["challenge"] = "mattr_chg";
@@ -1360,20 +1356,12 @@
     });
     const RequestCredentialsCrossDeviceOptionsValidator = object({
         credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        crossDeviceCallback: object({
-            onComplete: function_(),
-            onFailure: function_()
-        }),
         challenge: optional(string()),
         walletProviderId: optional(string()),
         mode: picklist([ exports.Mode.crossDevice ])
     });
     const RequestCredentialsAutoDetectDeviceOptionsValidator = object({
         credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        crossDeviceCallback: object({
-            onComplete: function_(),
-            onFailure: function_()
-        }),
         redirectUri: string(),
         challenge: optional(string()),
         walletProviderId: optional(string()),
@@ -1383,10 +1371,28 @@
     exports.RequestCredentialsErrorType = void 0;
     (function(RequestCredentialsErrorType) {
         RequestCredentialsErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
+        RequestCredentialsErrorType["Timeout"] = "Timeout";
+        RequestCredentialsErrorType["Abort"] = "Abort";
     })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
+    var RequestCredentialsErrorMessage;
+    (function(RequestCredentialsErrorMessage) {
+        RequestCredentialsErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
+        RequestCredentialsErrorMessage["FailedToGetSessionStatus"] = "Failed to get session status";
+        RequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
+        RequestCredentialsErrorMessage["Abort"] = "User aborted the session";
+        RequestCredentialsErrorMessage["Timeout"] = "User session timeout";
+    })(RequestCredentialsErrorMessage || (RequestCredentialsErrorMessage = {}));
+    exports.AbortSessionErrorType = void 0;
+    (function(AbortSessionErrorType) {
+        AbortSessionErrorType["AbortSessionFailed"] = "AbortSessionFailed";
+    })(exports.AbortSessionErrorType || (exports.AbortSessionErrorType = {}));
+    var AbortSessionErrorMessage;
+    (function(AbortSessionErrorMessage) {
+        AbortSessionErrorMessage["FailedToAbortSession"] = "Failed to abort session";
+    })(AbortSessionErrorMessage || (AbortSessionErrorMessage = {}));
     const InitialiseOptionsValidator = object({
-        apiBaseUrl: string(),
-        applicationId: optional(string())
+        apiBaseUrl: pipe(string(), nonEmpty("Must not be empty")),
+        applicationId: pipe(string(), nonEmpty("Must not be empty"))
     });
     let initialiseOptions = undefined;
     var InitialiseErrorMessage;
@@ -1398,6 +1404,34 @@
         initialiseOptions = options;
     };
     const getInitialiseOptions = () => initialiseOptions;
+    let sessionAbortController = undefined;
+    let _sessionId = undefined;
+    let _sessionKey = undefined;
+    const getActiveSession = () => {
+        const sessionId = _sessionId;
+        const sessionKey = _sessionKey;
+        if (sessionId) {
+            return {
+                sessionId: sessionId,
+                sessionKey: sessionKey
+            };
+        }
+        return undefined;
+    };
+    const setActiveSession = session => {
+        const {sessionId: sessionId, sessionKey: sessionKey} = session;
+        _sessionId = sessionId;
+        _sessionKey = sessionKey;
+        const abortController = new AbortController;
+        sessionAbortController = abortController;
+        return abortController;
+    };
+    const removeActiveSession = () => {
+        sessionAbortController === null || sessionAbortController === void 0 ? void 0 : sessionAbortController.abort();
+        sessionAbortController = undefined;
+        _sessionKey = undefined;
+        _sessionId = undefined;
+    };
     var isMobile_1 = isMobile;
     var isMobile_2 = isMobile;
     var default_1 = isMobile;
@@ -1422,6 +1456,23 @@
     isMobile_1["default"] = default_1;
     const defaultRetryDelay = attempt => Math.pow(2, attempt) * 1e3;
     const defaultRetry = 2;
+    const withRetry = async (fn, options) => {
+        const {retries: retries = defaultRetry, retryDelay: retryDelay = defaultRetryDelay, attempt: attempt = 0} = options;
+        try {
+            return await fn();
+        } catch (err) {
+            if (retries > 0) {
+                const delay = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+                await new Promise((resolve => setTimeout(resolve, delay)));
+                return await withRetry(fn, Object.assign(Object.assign({}, options), {
+                    retries: retries - 1,
+                    retryDelay: retryDelay,
+                    attempt: attempt + 1
+                }));
+            }
+            throw err;
+        }
+    };
     const withRetrySafeFetch = async (fn, options) => {
         const {retries: retries = defaultRetry, retryDelay: retryDelay = defaultRetryDelay, attempt: attempt = 0, retryHttpStatus: retryHttpStatus} = options;
         const result = await fn();
@@ -1448,13 +1499,12 @@
         return urlParams.get(param);
     };
     const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, applicationId: applicationId, walletProviderId: walletProviderId}) => {
-        const postData = Object.assign(Object.assign(Object.assign({
+        const postData = Object.assign(Object.assign({
             credentialQuery: credentialQuery,
-            challenge: challenge
+            challenge: challenge,
+            applicationId: applicationId
         }, redirectUri ? {
             redirectUri: redirectUri
-        } : {}), applicationId ? {
-            applicationId: applicationId
         } : {}), walletProviderId ? {
             walletProviderId: walletProviderId
         } : {});
@@ -1477,6 +1527,38 @@
         }
         return ok(data);
     };
+    const abortSession = async ({apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey}) => {
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/abort`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${sessionKey}`
+            }
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        return ok(undefined);
+    };
+    const getSessionStatus = async ({apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey}) => {
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/status`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${sessionKey}`
+            }
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        const data = await responseResult.value.json();
+        if (!isType(GetSessionStatusResponseValidator)(data)) {
+            return err({
+                type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
+                message: "Get session status return unsupported response"
+            });
+        }
+        return ok(data);
+    };
     const exchangeSessionResult = async ({challenge: challenge, responseCode: responseCode, sessionId: sessionId, apiBaseUrl: apiBaseUrl}) => {
         const postData = {
             challenge: challenge,
@@ -1512,26 +1594,16 @@
         ua: userAgent,
         tablet: false
     });
-    exports.CrossDeviceCallbackErrorType = void 0;
-    (function(CrossDeviceCallbackErrorType) {
-        CrossDeviceCallbackErrorType["Timeout"] = "Timeout";
-        CrossDeviceCallbackErrorType["Abort"] = "Abort";
-        CrossDeviceCallbackErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
-    })(exports.CrossDeviceCallbackErrorType || (exports.CrossDeviceCallbackErrorType = {}));
-    var CrossDeviceRequestCredentialsErrorMessage;
-    (function(CrossDeviceRequestCredentialsErrorMessage) {
-        CrossDeviceRequestCredentialsErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
-        CrossDeviceRequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
-        CrossDeviceRequestCredentialsErrorMessage["Abort"] = "User aborted the session";
-        CrossDeviceRequestCredentialsErrorMessage["Timeout"] = "User session timeout";
-    })(CrossDeviceRequestCredentialsErrorMessage || (CrossDeviceRequestCredentialsErrorMessage = {}));
     var WindowEventListenerType;
     (function(WindowEventListenerType) {
         WindowEventListenerType["message"] = "message";
     })(WindowEventListenerType || (WindowEventListenerType = {}));
-    let listener;
+    let listener = undefined;
     const removeWindowMessageEventListener = () => {
-        window.removeEventListener(WindowEventListenerType.message, listener, false);
+        if (listener) {
+            window.removeEventListener(WindowEventListenerType.message, listener, false);
+        }
+        listener = undefined;
     };
     const closeCrossDeviceModal = options => {
         const {container: container} = options;
@@ -1541,8 +1613,7 @@
         removeWindowMessageEventListener();
     };
     const receiveMessageHandler = options => async event => {
-        const {crossDeviceCallback: crossDeviceCallback, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge} = options;
-        const {onComplete: onComplete, onFailure: onFailure} = crossDeviceCallback;
+        const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge} = options;
         if (event.origin !== apiBaseUrl) {
             return;
         }
@@ -1556,8 +1627,8 @@
             });
             if (result.isErr()) {
                 onFailure({
-                    type: exports.CrossDeviceCallbackErrorType.RequestCredentialsFailed,
-                    message: CrossDeviceRequestCredentialsErrorMessage.FailedToGetSessionResult
+                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                    message: RequestCredentialsErrorMessage.FailedToGetSessionResult
                 });
                 closeCrossDeviceModal({
                     container: container
@@ -1565,8 +1636,9 @@
                 return;
             }
             onComplete({
-                result: result.value,
-                sessionId: result.value.sessionId
+                result: "challenge" in result.value ? result.value : undefined,
+                sessionId: result.value.sessionId,
+                sessionCompletedInRedirect: false
             });
             closeCrossDeviceModal({
                 container: container
@@ -1575,8 +1647,8 @@
         }
         if (event.data.type === MessageEventDataType.PresentationTimeout) {
             onFailure({
-                type: exports.CrossDeviceCallbackErrorType.Timeout,
-                message: CrossDeviceRequestCredentialsErrorMessage.Timeout
+                type: exports.RequestCredentialsErrorType.Timeout,
+                message: RequestCredentialsErrorMessage.Timeout
             });
             closeCrossDeviceModal({
                 container: container
@@ -1585,8 +1657,8 @@
         }
         if (event.data.type === MessageEventDataType.PresentationAbort) {
             onFailure({
-                type: exports.CrossDeviceCallbackErrorType.Abort,
-                message: CrossDeviceRequestCredentialsErrorMessage.Abort
+                type: exports.RequestCredentialsErrorType.Abort,
+                message: RequestCredentialsErrorMessage.Abort
             });
             closeCrossDeviceModal({
                 container: container
@@ -1610,7 +1682,7 @@
         return modalContainer;
     };
     const requestCredentialsCrossDevice = async options => {
-        const {challenge: challenge, walletProviderId: walletProviderId, credentialQuery: credentialQuery, crossDeviceCallback: crossDeviceCallback, initialiseOptions: initialiseOptions} = options;
+        const {challenge: challenge, walletProviderId: walletProviderId, credentialQuery: credentialQuery, initialiseOptions: initialiseOptions} = options;
         const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
         const createSessionResult = await createSession({
             credentialQuery: credentialQuery,
@@ -1622,27 +1694,44 @@
         if (createSessionResult.isErr()) {
             return err({
                 type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: CrossDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+                message: RequestCredentialsErrorMessage.FailedToCreateSession,
                 cause: createSessionResult.error
             });
         }
-        const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
+        const {sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey} = createSessionResult.value;
         const container = openCrossDeviceModal({
-            sessionUrl: sessionUrl,
-            crossDeviceCallback: crossDeviceCallback
-        });
-        listener = receiveMessageHandler({
-            crossDeviceCallback: crossDeviceCallback,
-            container: container,
-            sessionId: sessionId,
-            apiBaseUrl: apiBaseUrl,
-            challenge: challenge
-        });
-        window.addEventListener(WindowEventListenerType.message, listener, false);
-        return ok({
-            sessionId: sessionId
+            sessionUrl: sessionUrl
         });
+        return await new Promise((resolve => {
+            const abortController = setActiveSession({
+                sessionId: sessionId,
+                sessionKey: sessionKey
+            });
+            abortController.signal.addEventListener("abort", (() => {
+                closeCrossDeviceModal({
+                    container: container
+                });
+                resolve(err({
+                    type: exports.RequestCredentialsErrorType.Abort,
+                    message: RequestCredentialsErrorMessage.Abort
+                }));
+            }));
+            removeWindowMessageEventListener();
+            listener = receiveMessageHandler({
+                container: container,
+                sessionId: sessionId,
+                apiBaseUrl: apiBaseUrl,
+                challenge: challenge,
+                onComplete: data => resolve(ok(data)),
+                onFailure: error => resolve(err(error))
+            });
+            window.addEventListener(WindowEventListenerType.message, listener, false);
+        }));
     };
+    const sleep = ms => new Promise((resolve => setTimeout(resolve, ms)));
+    const SESSION_STATUS_POLLING_MAX_RETRY = 1e3;
+    const SESSION_STATUS_POLLING_INTERVAL_MS = 3e3;
+    const SESSION_STATUS_POLLING_INITIAL_DELAY_MS = 3e3;
     var SameDeviceRequestCredentialsErrorMessage;
     (function(SameDeviceRequestCredentialsErrorMessage) {
         SameDeviceRequestCredentialsErrorMessage["FailedToStoreChallenge"] = "Failed to store challenge";
@@ -1651,17 +1740,9 @@
     const requestCredentialsSameDevice = async options => {
         const {challenge: challenge, credentialQuery: credentialQuery, redirectUri: redirectUri, walletProviderId: walletProviderId, initialiseOptions: initialiseOptions} = options;
         const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
-        window.localStorage.setItem(LocalStorageKey.challenge, challenge);
-        const storedChallenge = window.localStorage.getItem(LocalStorageKey.challenge);
-        if (!storedChallenge) {
-            return err({
-                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
-            });
-        }
         const createSessionResult = await createSession({
             credentialQuery: credentialQuery,
-            challenge: storedChallenge,
+            challenge: challenge,
             redirectUri: redirectUri,
             apiBaseUrl: apiBaseUrl,
             applicationId: applicationId,
@@ -1674,11 +1755,52 @@
                 cause: createSessionResult.error
             });
         }
-        const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
+        const {sessionUrl: sessionUrl, sessionKey: sessionKey, sessionId: sessionId} = createSessionResult.value;
+        const abortController = setActiveSession({
+            sessionId: sessionId,
+            sessionKey: sessionKey
+        });
         window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
+        window.localStorage.setItem(LocalStorageKey.challenge, challenge);
         window.location.assign(sessionUrl);
+        await sleep(SESSION_STATUS_POLLING_INITIAL_DELAY_MS);
+        const checkResult = await withRetry((async () => {
+            const statusResult = await getSessionStatus({
+                apiBaseUrl: apiBaseUrl,
+                applicationId: applicationId,
+                sessionId: sessionId,
+                sessionKey: sessionKey
+            });
+            if (abortController.signal.aborted) {
+                return err({
+                    type: exports.RequestCredentialsErrorType.Abort,
+                    message: RequestCredentialsErrorMessage.Abort
+                });
+            }
+            if (statusResult.isErr()) {
+                if (statusResult.error.status === 404) {
+                    return err({
+                        type: exports.RequestCredentialsErrorType.Timeout,
+                        message: RequestCredentialsErrorMessage.Timeout
+                    });
+                }
+                throw Error("Unexpected status response. Retry");
+            }
+            if (statusResult.value.status !== PresentationStatusCode.ResultReady) {
+                throw Error("Result is not ready. Retry");
+            }
+            return ok(undefined);
+        }), {
+            retries: SESSION_STATUS_POLLING_MAX_RETRY,
+            retryDelay: SESSION_STATUS_POLLING_INTERVAL_MS
+        });
+        if (checkResult.isErr()) {
+            return err(checkResult.error);
+        }
+        window.close();
         return ok({
-            sessionId: sessionId
+            sessionId: sessionId,
+            sessionCompletedInRedirect: true
         });
     };
     const requestCredentials = async options => {
@@ -1697,16 +1819,11 @@
                 mode: mode
             }));
         }
-        if (mode === exports.Mode.crossDevice && "crossDeviceCallback" in options) {
-            return await requestCredentialsCrossDevice(Object.assign(Object.assign({}, options), {
-                initialiseOptions: initialiseOptions,
-                challenge: challenge,
-                mode: mode
-            }));
-        }
-        throw new Exception("Invalid request credential options", {
-            data: options
-        });
+        return await requestCredentialsCrossDevice(Object.assign(Object.assign({}, options), {
+            initialiseOptions: initialiseOptions,
+            challenge: challenge,
+            mode: exports.Mode.crossDevice
+        }));
     };
     exports.HandleRedirectCallbackErrorType = void 0;
     (function(HandleRedirectCallbackErrorType) {
@@ -1716,7 +1833,7 @@
     (function(HandleRedirectCallbackErrorMessage) {
         HandleRedirectCallbackErrorMessage["FailedToFindResponseCode"] = "Failed to find response code";
         HandleRedirectCallbackErrorMessage["FailedToFindChallenge"] = "Failed to find challenge";
-        HandleRedirectCallbackErrorMessage["FailedToFindSessionId"] = "Failed to find sessionId";
+        HandleRedirectCallbackErrorMessage["FailedToFindActiveSession"] = "Failed to find active session";
         HandleRedirectCallbackErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
     })(HandleRedirectCallbackErrorMessage || (HandleRedirectCallbackErrorMessage = {}));
     const handleRedirectCallback = async () => {
@@ -1732,18 +1849,12 @@
                 message: HandleRedirectCallbackErrorMessage.FailedToFindResponseCode
             });
         }
-        const challenge = window.localStorage.getItem(LocalStorageKey.challenge);
-        if (!challenge) {
-            return err({
-                type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
-                message: HandleRedirectCallbackErrorMessage.FailedToFindChallenge
-            });
-        }
         const sessionId = window.localStorage.getItem(LocalStorageKey.sessionId);
-        if (!sessionId) {
+        const challenge = window.localStorage.getItem(LocalStorageKey.challenge);
+        if (!sessionId || !challenge) {
             return err({
                 type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
-                message: HandleRedirectCallbackErrorMessage.FailedToFindSessionId
+                message: HandleRedirectCallbackErrorMessage.FailedToFindActiveSession
             });
         }
         const result = await exchangeSessionResult({
@@ -1760,14 +1871,42 @@
             });
         }
         return ok({
-            result: result.value,
+            result: "challenge" in result.value ? result.value : undefined,
             sessionId: result.value.sessionId
         });
     };
+    const abortCredentialRequest = async () => {
+        const initialiseOptions = getInitialiseOptions();
+        if (!initialiseOptions) {
+            throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+        }
+        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
+        const session = getActiveSession();
+        if (!session || !session.sessionKey) {
+            return ok(undefined);
+        }
+        const {sessionId: sessionId, sessionKey: sessionKey} = session;
+        removeActiveSession();
+        const abortSessionResult = await abortSession({
+            apiBaseUrl: apiBaseUrl,
+            applicationId: applicationId,
+            sessionId: sessionId,
+            sessionKey: sessionKey
+        });
+        if (abortSessionResult.isErr()) {
+            return err({
+                type: exports.AbortSessionErrorType.AbortSessionFailed,
+                message: AbortSessionErrorMessage.FailedToAbortSession,
+                cause: abortSessionResult.error
+            });
+        }
+        return ok(undefined);
+    };
     const utils = {
         generateChallenge: generateChallenge,
         unwrap: unwrap
     };
+    exports.abortCredentialRequest = abortCredentialRequest;
     exports.handleRedirectCallback = handleRedirectCallback;
     exports.initialise = initialise;
     exports.requestCredentials = requestCredentials;