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

package/README.md

@@ -203,15 +203,13 @@ const result = await MATTRVerifierSDK.requestCredentials({
   challenge: MATTRVerifierSDK.utils.generateChallenge(), // Pass a unique challenge
   walletProviderId, // Define the wallet identifier
   redirectUri, // Define the redirect URI (not required for cross-device only requests)
-  crossDeviceCallback: { // Define how to handle completion/failure of cross-device flows (not required for same-device only requests)
-    onComplete: (result) => {
-      console.info("<<< MATTRVerifierSDK.requestCredentials crossDeviceCallback.onComplete", result);
-    },
-    onFailure: (error) => {
-      console.info("<<< MATTRVerifierSDK.requestCredentials crossDeviceCallback.onFailure", error);
-    },
-  },
 });
+
+if (result.isErr()) {
+  console.info("<<< MATTRVerifierSDK.requestCredentials succeed", result.error);
+} else {
+  console.info("<<< MATTRVerifierSDK.requestCredentials failure", result.value);
+}
 ```
 * `apiBaseUrl` : Replace with the [`tenant_url`](https://learn.mattr.global/docs/platform-management/authentication) of your MATTR VII verifier tenant.
 * `credentialQuery`: The credential query to be used in the request.
@@ -219,7 +217,6 @@ const result = await MATTRVerifierSDK.requestCredentials({
 * `walletProviderId`: Replace with a wallet identifier that matches one of the values in the [`walletProviders` array](https://learn.mattr.global/api-reference/latest/tag/mDocs-verification#operation/putVerifierConfiguration!path=walletProviders/id&t=request) of the MATTR VII tenant's verifier configuration.
 * `mode`: When omitted, the SDK defaults to automatically selecting a flow based on the browser's user agent (set to `undefined` in the example for clarity).
 * `redirectUri` Replace with a URI that matches one of the values in the [`redirectUris` array](https://learn.mattr.global/api-reference/latest/tag/mDocs-verification#operation/postVerifierApplication!path=openid4vpConfiguration/redirectUris&t=request) in the MATTR VII tenant's verifier application configuration.
-* `crossDeviceCallback`: Defines how to handle completion (`onComplete`) or failure (`onFailure`) of the verification workflow.
 
 ## Request credentials with explicit same-device flow
 
@@ -253,15 +250,13 @@ const result = await MATTRVerifierSDK.requestCredentials({
   challenge: MATTRVerifierSDK.utils.generateChallenge(),
   walletProviderId,
   mode: "crossDevice",
-  crossDeviceCallback: {
-    onComplete: (result) => {
-      console.info("<<< MATTRVerifierSDK.requestCredentials crossDeviceCallback.onComplete", result);
-    },
-    onFailure: (error) => {
-      console.info("<<< MATTRVerifierSDK.requestCredentials crossDeviceCallback.onFailure", error);
-    },
-  },
 });
+
+if (result.isErr()) {
+  console.info("<<< MATTRVerifierSDK.requestCredentials succeed", result.error);
+} else {
+  console.info("<<< MATTRVerifierSDK.requestCredentials failure", result.value);
+}
 ```
 
 * `mode`: When set to `crossDevice`, the SDK will only support cross-device flow in this verification workflow.

package/dist/lib/verifier-js-no-deps.cjs.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:
  */
@@ -164,6 +164,15 @@ exports.OpenidPresentationCredentialProfileSupported = void 0;
     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 = v__namespace.object({
     profile: v__namespace.picklist([ exports.OpenidPresentationCredentialProfileSupported.MOBILE ]),
     docType: v__namespace.string(),
@@ -200,9 +209,27 @@ v__namespace.object({
 
 const CreateSessionResponseValidator = v__namespace.object({
     sessionId: v__namespace.string(),
+    sessionKey: v__namespace.string(),
     sessionUrl: v__namespace.string()
 });
 
+v__namespace.object({
+    sessionId: v__namespace.string(),
+    sessionKey: v__namespace.string()
+});
+
+v__namespace.object({
+    sessionId: v__namespace.string(),
+    sessionKey: v__namespace.string()
+});
+
+const GetSessionStatusResponseValidator = v__namespace.union([ v__namespace.object({
+    status: v__namespace.picklist([ PresentationStatusCode.ResultReady ]),
+    responseCode: v__namespace.optional(v__namespace.string())
+}), v__namespace.object({
+    status: v__namespace.string()
+}) ]);
+
 var LocalStorageKey;
 
 (function(LocalStorageKey) {
@@ -235,10 +262,6 @@ const RequestCredentialsSameDeviceOptionsValidator = v__namespace.object({
 
 const RequestCredentialsCrossDeviceOptionsValidator = v__namespace.object({
     credentialQuery: v__namespace.pipe(v__namespace.array(CredentialQueryValidator), v__namespace.nonEmpty()),
-    crossDeviceCallback: v__namespace.object({
-        onComplete: v__namespace.function(),
-        onFailure: v__namespace.function()
-    }),
     challenge: v__namespace.optional(v__namespace.string()),
     walletProviderId: v__namespace.optional(v__namespace.string()),
     mode: v__namespace.picklist([ exports.Mode.crossDevice ])
@@ -246,10 +269,6 @@ const RequestCredentialsCrossDeviceOptionsValidator = v__namespace.object({
 
 const RequestCredentialsAutoDetectDeviceOptionsValidator = v__namespace.object({
     credentialQuery: v__namespace.pipe(v__namespace.array(CredentialQueryValidator), v__namespace.nonEmpty()),
-    crossDeviceCallback: v__namespace.object({
-        onComplete: v__namespace.function(),
-        onFailure: v__namespace.function()
-    }),
     redirectUri: v__namespace.string(),
     challenge: v__namespace.optional(v__namespace.string()),
     walletProviderId: v__namespace.optional(v__namespace.string()),
@@ -262,11 +281,35 @@ 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 = v__namespace.object({
-    apiBaseUrl: v__namespace.string(),
-    applicationId: v__namespace.optional(v__namespace.string())
+    apiBaseUrl: v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("Must not be empty")),
+    applicationId: v__namespace.pipe(v__namespace.string(), v__namespace.nonEmpty("Must not be empty"))
 });
 
 let initialiseOptions = undefined;
@@ -284,10 +327,62 @@ const initialise = 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;
+};
+
 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();
@@ -317,13 +412,12 @@ const getHashParamValue = (hash, 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
     } : {});
@@ -347,6 +441,40 @@ const createSession = async ({credentialQuery: credentialQuery, challenge: chall
     return neverthrow.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 neverthrow.err(responseResult.error);
+    }
+    return neverthrow.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 neverthrow.err(responseResult.error);
+    }
+    const data = await responseResult.value.json();
+    if (!isType(GetSessionStatusResponseValidator)(data)) {
+        return neverthrow.err({
+            type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
+            message: "Get session status return unsupported response"
+        });
+    }
+    return neverthrow.ok(data);
+};
+
 const exchangeSessionResult = async ({challenge: challenge, responseCode: responseCode, sessionId: sessionId, apiBaseUrl: apiBaseUrl}) => {
     const postData = {
         challenge: challenge,
@@ -384,33 +512,19 @@ const isMobileDetect = userAgent => isMobile.isMobile({
     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 => {
@@ -422,8 +536,7 @@ const closeCrossDeviceModal = options => {
 };
 
 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;
     }
@@ -437,8 +550,8 @@ const receiveMessageHandler = options => async event => {
         });
         if (result.isErr()) {
             onFailure({
-                type: exports.CrossDeviceCallbackErrorType.RequestCredentialsFailed,
-                message: CrossDeviceRequestCredentialsErrorMessage.FailedToGetSessionResult
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.FailedToGetSessionResult
             });
             closeCrossDeviceModal({
                 container: container
@@ -446,8 +559,9 @@ const receiveMessageHandler = options => async event => {
             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
@@ -456,8 +570,8 @@ const receiveMessageHandler = options => async event => {
     }
     if (event.data.type === MessageEventDataType.PresentationTimeout) {
         onFailure({
-            type: exports.CrossDeviceCallbackErrorType.Timeout,
-            message: CrossDeviceRequestCredentialsErrorMessage.Timeout
+            type: exports.RequestCredentialsErrorType.Timeout,
+            message: RequestCredentialsErrorMessage.Timeout
         });
         closeCrossDeviceModal({
             container: container
@@ -466,8 +580,8 @@ const receiveMessageHandler = options => async event => {
     }
     if (event.data.type === MessageEventDataType.PresentationAbort) {
         onFailure({
-            type: exports.CrossDeviceCallbackErrorType.Abort,
-            message: CrossDeviceRequestCredentialsErrorMessage.Abort
+            type: exports.RequestCredentialsErrorType.Abort,
+            message: RequestCredentialsErrorMessage.Abort
         });
         closeCrossDeviceModal({
             container: container
@@ -493,7 +607,7 @@ const openCrossDeviceModal = options => {
 };
 
 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,
@@ -505,28 +619,49 @@ const requestCredentialsCrossDevice = async options => {
     if (createSessionResult.isErr()) {
         return neverthrow.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 neverthrow.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(neverthrow.err({
+                type: exports.RequestCredentialsErrorType.Abort,
+                message: RequestCredentialsErrorMessage.Abort
+            }));
+        }));
+        removeWindowMessageEventListener();
+        listener = receiveMessageHandler({
+            container: container,
+            sessionId: sessionId,
+            apiBaseUrl: apiBaseUrl,
+            challenge: challenge,
+            onComplete: data => resolve(neverthrow.ok(data)),
+            onFailure: error => resolve(neverthrow.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) {
@@ -537,17 +672,9 @@ var SameDeviceRequestCredentialsErrorMessage;
 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 neverthrow.err({
-            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
-        });
-    }
     const createSessionResult = await createSession({
         credentialQuery: credentialQuery,
-        challenge: storedChallenge,
+        challenge: challenge,
         redirectUri: redirectUri,
         apiBaseUrl: apiBaseUrl,
         applicationId: applicationId,
@@ -560,11 +687,52 @@ const requestCredentialsSameDevice = async options => {
             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 neverthrow.err({
+                type: exports.RequestCredentialsErrorType.Abort,
+                message: RequestCredentialsErrorMessage.Abort
+            });
+        }
+        if (statusResult.isErr()) {
+            if (statusResult.error.status === 404) {
+                return neverthrow.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 neverthrow.ok(undefined);
+    }), {
+        retries: SESSION_STATUS_POLLING_MAX_RETRY,
+        retryDelay: SESSION_STATUS_POLLING_INTERVAL_MS
+    });
+    if (checkResult.isErr()) {
+        return neverthrow.err(checkResult.error);
+    }
+    window.close();
     return neverthrow.ok({
-        sessionId: sessionId
+        sessionId: sessionId,
+        sessionCompletedInRedirect: true
     });
 };
 
@@ -584,16 +752,11 @@ const requestCredentials = async options => {
             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;
@@ -607,7 +770,7 @@ var HandleRedirectCallbackErrorMessage;
 (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 = {}));
 
@@ -624,18 +787,12 @@ const handleRedirectCallback = async () => {
             message: HandleRedirectCallbackErrorMessage.FailedToFindResponseCode
         });
     }
-    const challenge = window.localStorage.getItem(LocalStorageKey.challenge);
-    if (!challenge) {
-        return neverthrow.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 neverthrow.err({
             type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
-            message: HandleRedirectCallbackErrorMessage.FailedToFindSessionId
+            message: HandleRedirectCallbackErrorMessage.FailedToFindActiveSession
         });
     }
     const result = await exchangeSessionResult({
@@ -652,16 +809,46 @@ const handleRedirectCallback = async () => {
         });
     }
     return neverthrow.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 neverthrow.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 neverthrow.err({
+            type: exports.AbortSessionErrorType.AbortSessionFailed,
+            message: AbortSessionErrorMessage.FailedToAbortSession,
+            cause: abortSessionResult.error
+        });
+    }
+    return neverthrow.ok(undefined);
+};
+
 const utils = {
     generateChallenge: generateChallenge,
     unwrap: unwrap
 };
 
+exports.abortCredentialRequest = abortCredentialRequest;
+
 exports.handleRedirectCallback = handleRedirectCallback;
 
 exports.initialise = initialise;