@mattrglobal/verifier-sdk-web 1.1.1-unstable.15 → 1.1.1-unstable.154

package/dist/lib/verifier-js.cjs.js

@@ -7,7 +7,7 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2025-01-14
+ * Generated: 2025-05-18
  * Version: 1.1.0
  * Dependencies:
  *
@@ -446,148 +446,137 @@ ResultAsync.fromPromise;
 
 ResultAsync.fromSafePromise;
 
-function ownKeys(e, r) {
-    var t = Object.keys(e);
-    if (Object.getOwnPropertySymbols) {
-        var o = Object.getOwnPropertySymbols(e);
-        r && (o = o.filter((function(r) {
-            return Object.getOwnPropertyDescriptor(e, r).enumerable;
-        }))), t.push.apply(t, o);
-    }
-    return t;
-}
-
-function _objectSpread2(e) {
-    for (var r = 1; r < arguments.length; r++) {
-        var t = null != arguments[r] ? arguments[r] : {};
-        r % 2 ? ownKeys(Object(t), !0).forEach((function(r) {
-            _defineProperty(e, r, t[r]);
-        })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach((function(r) {
-            Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-        }));
-    }
-    return e;
-}
-
-function _typeof(o) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-        return typeof o;
-    } : function(o) {
-        return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-    }, _typeof(o);
-}
-
-function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
 }
 
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _arrayWithoutHoles(r) {
+    if (Array.isArray(r)) return _arrayLikeToArray(r);
 }
 
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-    return arr2;
-}
-
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _createForOfIteratorHelper(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-    if (!it) {
-        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-            if (it) o = it;
-            var i = 0;
-            var F = function() {};
+function _createForOfIteratorHelper(r, e) {
+    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (!t) {
+        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+            t && (r = t);
+            var n = 0, F = function() {};
             return {
                 s: F,
                 n: function() {
-                    if (i >= o.length) return {
-                        done: true
-                    };
-                    return {
-                        done: false,
-                        value: o[i++]
+                    return n >= r.length ? {
+                        done: !0
+                    } : {
+                        done: !1,
+                        value: r[n++]
                     };
                 },
-                e: function(e) {
-                    throw e;
+                e: function(r) {
+                    throw r;
                 },
                 f: F
             };
         }
         throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
     }
-    var normalCompletion = true, didErr = false, err;
+    var o, a = !0, u = !1;
     return {
         s: function() {
-            it = it.call(o);
+            t = t.call(r);
         },
         n: function() {
-            var step = it.next();
-            normalCompletion = step.done;
-            return step;
+            var r = t.next();
+            return a = r.done, r;
         },
-        e: function(e) {
-            didErr = true;
-            err = e;
+        e: function(r) {
+            u = !0, o = r;
         },
         f: function() {
             try {
-                if (!normalCompletion && it.return != null) it.return();
+                a || null == t.return || t.return();
             } finally {
-                if (didErr) throw err;
+                if (u) throw o;
             }
         }
     };
 }
 
-function _toPrimitive(input, hint) {
-    if (typeof input !== "object" || input === null) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== undefined) {
-        var res = prim.call(input, hint || "default");
-        if (typeof res !== "object") return res;
+function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+        value: t,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : e[r] = t, e;
+}
+
+function _iterableToArray(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+        var o = Object.getOwnPropertySymbols(e);
+        r && (o = o.filter((function(r) {
+            return Object.getOwnPropertyDescriptor(e, r).enumerable;
+        }))), t.push.apply(t, o);
+    }
+    return t;
+}
+
+function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+        var t = null != arguments[r] ? arguments[r] : {};
+        r % 2 ? ownKeys(Object(t), !0).forEach((function(r) {
+            _defineProperty(e, r, t[r]);
+        })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach((function(r) {
+            Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+        }));
+    }
+    return e;
+}
+
+function _toConsumableArray(r) {
+    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+
+function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+        var i = e.call(t, r || "default");
+        if ("object" != typeof i) return i;
         throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    return (hint === "string" ? String : Number)(input);
+    return ("string" === r ? String : Number)(t);
 }
 
-function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return typeof key === "symbol" ? key : String(key);
+function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+}
+
+function _typeof(o) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+        return typeof o;
+    } : function(o) {
+        return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+}
+
+function _unsupportedIterableToArray(r, a) {
+    if (r) {
+        if ("string" == typeof r) return _arrayLikeToArray(r, a);
+        var t = {}.toString.call(r).slice(8, -1);
+        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
 }
 
 var store;
@@ -708,6 +697,20 @@ function getDefault(schema, dataset, config2) {
     return typeof schema["default"] === "function" ? schema["default"](dataset, config2) : schema["default"];
 }
 
+function any() {
+    return {
+        kind: "schema",
+        type: "any",
+        reference: any,
+        expects: "any",
+        async: false,
+        _run: function _run(dataset) {
+            dataset.typed = true;
+            return dataset;
+        }
+    };
+}
+
 function array(item, message) {
     return {
         kind: "schema",
@@ -793,16 +796,36 @@ function _boolean(message) {
     };
 }
 
-function function_(message) {
+function literal(literal_, message) {
     return {
         kind: "schema",
-        type: "function",
-        reference: function_,
-        expects: "Function",
+        type: "literal",
+        reference: literal,
+        expects: _stringify(literal_),
         async: false,
+        literal: literal_,
         message: message,
         _run: function _run(dataset, config2) {
-            if (typeof dataset.value === "function") {
+            if (dataset.value === this.literal) {
+                dataset.typed = true;
+            } else {
+                _addIssue(this, "type", dataset, config2);
+            }
+            return dataset;
+        }
+    };
+}
+
+function number(message) {
+    return {
+        kind: "schema",
+        type: "number",
+        reference: number,
+        expects: "number",
+        async: false,
+        message: message,
+        _run: function _run(dataset, config2) {
+            if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
                 dataset.typed = true;
             } else {
                 _addIssue(this, "type", dataset, config2);
@@ -1307,47 +1330,21 @@ const assertType = (validator, message) => data => {
     }
 };
 
-var SafeFetchCommonRespondErrorType;
-
-(function(SafeFetchCommonRespondErrorType) {
-    SafeFetchCommonRespondErrorType["UnexpectedRespond"] = "UnexpectedRespond";
-})(SafeFetchCommonRespondErrorType || (SafeFetchCommonRespondErrorType = {}));
-
-var SafeFetchErrorType;
-
-(function(SafeFetchErrorType) {
-    SafeFetchErrorType["HttpError"] = "HttpError";
-    SafeFetchErrorType["UnknownError"] = "UnknownError";
-})(SafeFetchErrorType || (SafeFetchErrorType = {}));
-
-const safeFetch = async (input, init) => {
-    try {
-        const response = await fetch(input, init);
-        if (response.status > 299 || response.status < 200) {
-            return err({
-                type: SafeFetchErrorType.HttpError,
-                message: `HTTP error, status = ${response.status}`,
-                status: response.status
-            });
-        }
-        return ok(response);
-    } catch (error) {
-        return err({
-            type: SafeFetchErrorType.UnknownError,
-            message: "Unknown error",
-            cause: error
-        });
-    }
-};
-
 exports.MobileCredentialVerificationReasonType = void 0;
 
 (function(MobileCredentialVerificationReasonType) {
-    MobileCredentialVerificationReasonType["Expired"] = "expired";
-    MobileCredentialVerificationReasonType["Inactive"] = "inactive";
-    MobileCredentialVerificationReasonType["StatusRevoked"] = "invalid";
-    MobileCredentialVerificationReasonType["StatusSuspended"] = "suspended";
-    MobileCredentialVerificationReasonType["StatusUnknown"] = "unknown";
+    MobileCredentialVerificationReasonType["TrustedIssuerCertificateExpired"] = "TrustedIssuerCertificateExpired";
+    MobileCredentialVerificationReasonType["TrustedIssuerCertificateNotYetValid"] = "TrustedIssuerCertificateNotYetValid";
+    MobileCredentialVerificationReasonType["IssuerNotTrusted"] = "IssuerNotTrusted";
+    MobileCredentialVerificationReasonType["MobileCredentialInvalid"] = "MobileCredentialInvalid";
+    MobileCredentialVerificationReasonType["MobileCredentialExpired"] = "MobileCredentialExpired";
+    MobileCredentialVerificationReasonType["MobileCredentialNotYetValid"] = "MobileCredentialNotYetValid";
+    MobileCredentialVerificationReasonType["InvalidSignerCertificate"] = "InvalidSignerCertificate";
+    MobileCredentialVerificationReasonType["DeviceKeyInvalid"] = "DeviceKeyInvalid";
+    MobileCredentialVerificationReasonType["UnsupportedCurve"] = "UnsupportedCurve";
+    MobileCredentialVerificationReasonType["StatusRevoked"] = "StatusRevoked";
+    MobileCredentialVerificationReasonType["StatusSuspended"] = "StatusSuspended";
+    MobileCredentialVerificationReasonType["StatusUnknown"] = "StatusUnknown";
 })(exports.MobileCredentialVerificationReasonType || (exports.MobileCredentialVerificationReasonType = {}));
 
 exports.ClaimType = void 0;
@@ -1382,6 +1379,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 = object({
     profile: picklist([ exports.OpenidPresentationCredentialProfileSupported.MOBILE ]),
     docType: string(),
@@ -1409,18 +1415,52 @@ const PresentationResultRelaxValidator = object({
     error: optional(unknown())
 });
 
+exports.Mode = void 0;
+
+(function(Mode) {
+    Mode["SameDevice"] = "sameDevice";
+    Mode["CrossDevice"] = "crossDevice";
+})(exports.Mode || (exports.Mode = {}));
+
+var SessionType;
+
+(function(SessionType) {
+    SessionType["DigitalCredentialsApi"] = "digital-credentials-api";
+    SessionType["Openid4vp"] = "openid4vp";
+})(SessionType || (SessionType = {}));
+
 object({
     credentialQuery: array(CredentialQueryValidator),
     challenge: string(),
     redirectUri: optional(string()),
-    walletProviderId: optional(string())
+    walletProviderId: optional(string()),
+    dcApiSupported: optional(_boolean())
+});
+
+const CreateSessionDigitalCredentialsValidator = object({
+    type: literal(SessionType.DigitalCredentialsApi),
+    sessionId: string(),
+    sessionKey: string(),
+    sessionTtl: number(),
+    request: record(string(), any())
 });
 
-const CreateSessionResponseValidator = object({
+const CreateSessionOpenId4vpResponseValidator = object({
+    type: optional(literal(SessionType.Openid4vp)),
     sessionId: string(),
+    sessionKey: string(),
     sessionUrl: string()
 });
 
+const CreateSessionResponseValidator = union([ CreateSessionDigitalCredentialsValidator, CreateSessionOpenId4vpResponseValidator ]);
+
+const GetSessionStatusResponseValidator = union([ object({
+    status: picklist([ PresentationStatusCode.ResultReady ]),
+    responseCode: optional(string())
+}), object({
+    status: string()
+}) ]);
+
 var LocalStorageKey;
 
 (function(LocalStorageKey) {
@@ -1428,12 +1468,9 @@ var LocalStorageKey;
     LocalStorageKey["sessionId"] = "mattr_sid";
 })(LocalStorageKey || (LocalStorageKey = {}));
 
-exports.Mode = void 0;
+const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
 
-(function(Mode) {
-    Mode["sameDevice"] = "sameDevice";
-    Mode["crossDevice"] = "crossDevice";
-})(exports.Mode || (exports.Mode = {}));
+const MATTR_SDK_VERSION_VALUE = "2.0.0";
 
 var MessageEventDataType;
 
@@ -1443,50 +1480,106 @@ var MessageEventDataType;
     MessageEventDataType["PresentationAbort"] = "PresentationAbort";
 })(MessageEventDataType || (MessageEventDataType = {}));
 
-const RequestCredentialsSameDeviceOptionsValidator = object({
-    credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-    redirectUri: string(),
-    challenge: optional(string()),
+const OpenId4vpConfigSameDeviceOptionsValidator = object({
     walletProviderId: optional(string()),
-    mode: picklist([ exports.Mode.sameDevice ])
+    mode: literal(exports.Mode.SameDevice),
+    redirectUri: string()
 });
 
-const RequestCredentialsCrossDeviceOptionsValidator = object({
-    credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-    crossDeviceCallback: object({
-        onComplete: function_(),
-        onFailure: function_()
-    }),
-    challenge: optional(string()),
+const OpenId4vpConfigCrossDeviceOptionsValidator = object({
     walletProviderId: optional(string()),
-    mode: picklist([ exports.Mode.crossDevice ])
+    mode: literal(exports.Mode.CrossDevice)
 });
 
-const RequestCredentialsAutoDetectDeviceOptionsValidator = object({
-    credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-    crossDeviceCallback: object({
-        onComplete: function_(),
-        onFailure: function_()
-    }),
-    redirectUri: string(),
-    challenge: optional(string()),
+const OpenId4vpConfigAutoDetectOptionsValidator = object({
     walletProviderId: optional(string()),
-    mode: optional(picklist([ exports.Mode.crossDevice, exports.Mode.sameDevice ]))
+    redirectUri: string(),
+    mode: optional(picklist([ exports.Mode.CrossDevice, exports.Mode.SameDevice ]))
 });
 
-const RequestCredentialsOptionsValidator = union([ RequestCredentialsSameDeviceOptionsValidator, RequestCredentialsCrossDeviceOptionsValidator, RequestCredentialsAutoDetectDeviceOptionsValidator ]);
+const RequestCredentialsOptionsValidator = object({
+    credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
+    challenge: optional(string()),
+    openid4vpConfiguration: optional(union([ OpenId4vpConfigSameDeviceOptionsValidator, OpenId4vpConfigCrossDeviceOptionsValidator, OpenId4vpConfigAutoDetectOptionsValidator ]))
+});
 
 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["FailedToVerifyCredentialResponse"] = "Failed to verify credential response";
+    RequestCredentialsErrorMessage["MissingOpenId4vpConfig"] = "Identified openid4vp session, but missing openId4vpConfiguration on `requestCredentials`";
+    RequestCredentialsErrorMessage["DcApiError"] = "Failed to request credentials with Digital Credentials API";
+    RequestCredentialsErrorMessage["DcApiResponseParseError"] = "Failed to parse response from Digital Credentials API";
+    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"))
 });
 
+var SafeFetchCommonResponseErrorType;
+
+(function(SafeFetchCommonResponseErrorType) {
+    SafeFetchCommonResponseErrorType["UnexpectedResponse"] = "UnexpectedResponse";
+})(SafeFetchCommonResponseErrorType || (SafeFetchCommonResponseErrorType = {}));
+
+var SafeFetchErrorType;
+
+(function(SafeFetchErrorType) {
+    SafeFetchErrorType["HttpError"] = "HttpError";
+    SafeFetchErrorType["UnknownError"] = "UnknownError";
+})(SafeFetchErrorType || (SafeFetchErrorType = {}));
+
+const safeFetch = async (input, init) => {
+    try {
+        const headers = Object.assign(Object.assign({}, init === null || init === void 0 ? void 0 : init.headers), {
+            [MATTR_SDK_VERSION_HEADER]: `verifier-sdk-web/${MATTR_SDK_VERSION_VALUE}`
+        });
+        const response = await fetch(input, Object.assign(Object.assign({}, init), {
+            headers: headers
+        }));
+        if (response.status > 299 || response.status < 200) {
+            return err({
+                type: SafeFetchErrorType.HttpError,
+                message: `HTTP error, status = ${response.status}`,
+                status: response.status
+            });
+        }
+        return ok(response);
+    } catch (error) {
+        return err({
+            type: SafeFetchErrorType.UnknownError,
+            message: "Unknown error",
+            cause: error
+        });
+    }
+};
+
 let initialiseOptions = undefined;
 
 var InitialiseErrorMessage;
@@ -1502,6 +1595,49 @@ const initialise = options => {
 
 const getInitialiseOptions = () => initialiseOptions;
 
+let sessionAbortController = undefined;
+
+let _sessionId = undefined;
+
+let _sessionKey = undefined;
+
+let _sessionTimeoutId = undefined;
+
+const getActiveSession = () => {
+    const sessionId = _sessionId;
+    const sessionKey = _sessionKey;
+    const sessionTimeoutId = _sessionTimeoutId;
+    if (sessionId) {
+        return {
+            sessionId: sessionId,
+            sessionKey: sessionKey,
+            sessionTimeoutId: sessionTimeoutId
+        };
+    }
+    return undefined;
+};
+
+const setActiveSession = session => {
+    const {sessionId: sessionId, sessionKey: sessionKey, sessionTimeoutId: sessionTimeoutId} = session;
+    _sessionId = sessionId;
+    _sessionKey = sessionKey;
+    _sessionTimeoutId = sessionTimeoutId;
+    const abortController = new AbortController;
+    sessionAbortController = abortController;
+    return abortController;
+};
+
+const removeActiveSession = () => {
+    sessionAbortController === null || sessionAbortController === void 0 ? void 0 : sessionAbortController.abort();
+    if (_sessionTimeoutId) {
+        window.clearTimeout(_sessionTimeoutId);
+    }
+    sessionAbortController = undefined;
+    _sessionKey = undefined;
+    _sessionId = undefined;
+    _sessionTimeoutId = undefined;
+};
+
 var isMobile_1 = isMobile;
 
 var isMobile_2 = isMobile;
@@ -1537,6 +1673,24 @@ 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();
@@ -1565,17 +1719,15 @@ const getHashParamValue = (hash, param) => {
     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 createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId, dcApiSupported: dcApiSupported, applicationId: applicationId}) => {
+    const postData = {
         credentialQuery: credentialQuery,
-        challenge: challenge
-    }, redirectUri ? {
-        redirectUri: redirectUri
-    } : {}), applicationId ? {
-        applicationId: applicationId
-    } : {}), walletProviderId ? {
-        walletProviderId: walletProviderId
-    } : {});
+        challenge: challenge,
+        applicationId: applicationId,
+        redirectUri: redirectUri,
+        walletProviderId: walletProviderId,
+        dcApiSupported: dcApiSupported
+    };
     const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions`, {
         method: "POST",
         headers: {
@@ -1589,8 +1741,42 @@ const createSession = async ({credentialQuery: credentialQuery, challenge: chall
     const data = await responseResult.value.json();
     if (!isType(CreateSessionResponseValidator)(data)) {
         return err({
-            type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
-            message: "Create session return unsupported response"
+            type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+            message: "Create session returned unsupported response"
+        });
+    }
+    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: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+            message: "Get session status return unsupported response"
         });
     }
     return ok(data);
@@ -1618,7 +1804,7 @@ const exchangeSessionResult = async ({challenge: challenge, responseCode: respon
     const data = await responseResult.value.json();
     if (!isType(PresentationResultRelaxValidator)(data)) {
         return err({
-            type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
+            type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
             message: "Exchange session result return unsupported response",
             details: {
                 data: data
@@ -1633,22 +1819,7 @@ const isMobileDetect = userAgent => isMobile_2({
     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 = {}));
+const getVersion = () => MATTR_SDK_VERSION_VALUE;
 
 var WindowEventListenerType;
 
@@ -1656,10 +1827,13 @@ var 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 => {
@@ -1671,8 +1845,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;
     }
@@ -1686,8 +1859,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
@@ -1695,8 +1868,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
@@ -1705,8 +1879,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
@@ -1715,8 +1889,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
@@ -1741,41 +1915,198 @@ const openCrossDeviceModal = options => {
     return modalContainer;
 };
 
-const requestCredentialsCrossDevice = async options => {
-    const {challenge: challenge, walletProviderId: walletProviderId, credentialQuery: credentialQuery, crossDeviceCallback: crossDeviceCallback, initialiseOptions: initialiseOptions} = options;
-    const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
-    const createSessionResult = await createSession({
-        credentialQuery: credentialQuery,
-        challenge: challenge,
+const requestCredentialsWithCrossDevice = async options => {
+    const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey} = options;
+    const container = openCrossDeviceModal({
+        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 abortCredentialRequest = async () => {
+    const initialiseOptions = getInitialiseOptions();
+    if (!initialiseOptions) {
+        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+    }
+    const {apiBaseUrl: apiBaseUrl} = 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,
-        walletProviderId: walletProviderId
+        sessionId: sessionId,
+        sessionKey: sessionKey
     });
-    if (createSessionResult.isErr()) {
+    if (abortSessionResult.isErr()) {
         return err({
-            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: CrossDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
-            cause: createSessionResult.error
+            type: exports.AbortSessionErrorType.AbortSessionFailed,
+            message: AbortSessionErrorMessage.FailedToAbortSession,
+            cause: abortSessionResult.error
         });
     }
-    const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
-    const container = openCrossDeviceModal({
-        sessionUrl: sessionUrl,
-        crossDeviceCallback: crossDeviceCallback
-    });
-    listener = receiveMessageHandler({
-        crossDeviceCallback: crossDeviceCallback,
-        container: container,
+    return ok(undefined);
+};
+
+const requestCredentialsWithDigitalCredentialsApi = async options => {
+    const {apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey, challenge: challenge, request: request, sessionTtl: sessionTtl} = options;
+    const sessionTimeoutId = window.setTimeout((() => removeActiveSession()), sessionTtl * 1e3);
+    const abortController = setActiveSession({
         sessionId: sessionId,
+        sessionKey: sessionKey,
+        sessionTimeoutId: sessionTimeoutId
+    });
+    const credentialResponseResult = await getCredentials(request, abortController);
+    if (credentialResponseResult.isErr()) {
+        await abortCredentialRequest();
+        return err(credentialResponseResult.error);
+    }
+    const credentialResponse = credentialResponseResult.value;
+    const parsedCredentialResponseResult = parseCredentialResponse(credentialResponse);
+    if (parsedCredentialResponseResult.isErr()) {
+        await abortCredentialRequest();
+        return err(parsedCredentialResponseResult.error);
+    }
+    const parsedCredentialResponse = parsedCredentialResponseResult.value;
+    const credentialVerificationResult = await verifyCredentialResponse({
         apiBaseUrl: apiBaseUrl,
-        challenge: challenge
+        sessionId: sessionId,
+        sessionKey: sessionKey,
+        challenge: challenge,
+        protocol: parsedCredentialResponse.protocol,
+        data: parsedCredentialResponse.data
     });
-    window.addEventListener(WindowEventListenerType.message, listener, false);
-    return ok({
-        sessionId: sessionId
+    if (credentialVerificationResult.isErr()) {
+        return err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: RequestCredentialsErrorMessage.FailedToVerifyCredentialResponse,
+            cause: credentialVerificationResult.error
+        });
+    }
+    return ok(credentialVerificationResult.value);
+};
+
+const getCredentials = async (request, abortController) => {
+    try {
+        const credentialResponse = await navigator.credentials.get(Object.assign(Object.assign({}, request), {
+            signal: abortController.signal
+        }));
+        return ok(credentialResponse);
+    } catch (exception) {
+        return err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: RequestCredentialsErrorMessage.DcApiError,
+            cause: exception
+        });
+    }
+};
+
+const parseCredentialResponse = credentialResponse => {
+    if (!credentialResponse) {
+        return err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+            details: {
+                response: credentialResponse
+            }
+        });
+    }
+    if (typeof credentialResponse === "object") {
+        return ok(credentialResponse);
+    }
+    if (typeof credentialResponse === "string") {
+        try {
+            const parsed = JSON.parse(credentialResponse);
+            return ok(parsed);
+        } catch (_a) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+                details: {
+                    response: credentialResponse
+                }
+            });
+        }
+    }
+    return err({
+        type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+        message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+        details: {
+            response: credentialResponse
+        }
     });
 };
 
+const verifyCredentialResponse = async options => {
+    const {apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey, challenge: challenge, protocol: protocol, data: data} = options;
+    const requestBody = {
+        protocol: protocol,
+        data: data,
+        challenge: challenge
+    };
+    const credentialVerificationResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/dc-api/response`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${sessionKey}`
+        },
+        body: JSON.stringify(requestBody)
+    });
+    if (credentialVerificationResult.isErr()) {
+        return err(credentialVerificationResult.error);
+    }
+    const credentialVerificationResponse = await credentialVerificationResult.value.json();
+    if (!isType(PresentationResultRelaxValidator)(credentialVerificationResponse)) {
+        return err({
+            type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+            message: "Verify credential returned unsupported response",
+            details: {
+                response: credentialVerificationResponse
+            }
+        });
+    }
+    return ok(credentialVerificationResponse);
+};
+
+const isDigitalCredentialsApiSupported = () => {
+    var _a;
+    return "DigitalCredential" in window && typeof window.DigitalCredential === "function" && typeof ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.credentials) === null || _a === void 0 ? void 0 : _a.get) === "function";
+};
+
+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) {
@@ -1784,65 +2115,135 @@ var SameDeviceRequestCredentialsErrorMessage;
 })(SameDeviceRequestCredentialsErrorMessage || (SameDeviceRequestCredentialsErrorMessage = {}));
 
 const requestCredentialsSameDevice = async options => {
-    const {challenge: challenge, credentialQuery: credentialQuery, redirectUri: redirectUri, walletProviderId: walletProviderId, initialiseOptions: initialiseOptions} = options;
-    const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
+    const {challenge: challenge, apiBaseUrl: apiBaseUrl, applicationId: applicationId, sessionUrl: sessionUrl, sessionKey: sessionKey, sessionId: sessionId} = options;
+    const abortController = setActiveSession({
+        sessionId: sessionId,
+        sessionKey: sessionKey
+    });
+    window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
     window.localStorage.setItem(LocalStorageKey.challenge, challenge);
-    const storedChallenge = window.localStorage.getItem(LocalStorageKey.challenge);
-    if (!storedChallenge) {
-        return err({
-            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
+    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,
+        sessionCompletedInRedirect: true
+    });
+};
+
+const requestCredentials = async options => {
+    var _a;
+    const initialiseOptions = getInitialiseOptions();
+    if (!initialiseOptions) {
+        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
     }
+    assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
+    const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
+    const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration} = options;
+    const dcApiSupported = isDigitalCredentialsApiSupported();
+    const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
     const createSessionResult = await createSession({
         credentialQuery: credentialQuery,
-        challenge: storedChallenge,
-        redirectUri: redirectUri,
+        challenge: challenge,
+        redirectUri: openId4VpRedirectUri,
+        walletProviderId: (_a = openid4vpConfiguration === null || openid4vpConfiguration === void 0 ? void 0 : openid4vpConfiguration.walletProviderId) !== null && _a !== void 0 ? _a : undefined,
         apiBaseUrl: apiBaseUrl,
         applicationId: applicationId,
-        walletProviderId: walletProviderId
+        dcApiSupported: dcApiSupported
     });
     if (createSessionResult.isErr()) {
         return err({
             type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: SameDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+            message: RequestCredentialsErrorMessage.FailedToCreateSession,
             cause: createSessionResult.error
         });
     }
-    const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
-    window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
-    window.location.assign(sessionUrl);
-    return ok({
+    const session = createSessionResult.value;
+    const {sessionKey: sessionKey, sessionId: sessionId} = session;
+    if (session.type === SessionType.DigitalCredentialsApi) {
+        const {request: request, sessionTtl: sessionTtl} = session;
+        return await requestCredentialsWithDigitalCredentialsApi({
+            apiBaseUrl: apiBaseUrl,
+            request: request,
+            sessionId: sessionId,
+            sessionKey: sessionKey,
+            challenge: challenge,
+            sessionTtl: sessionTtl
+        });
+    }
+    if (!openid4vpConfiguration) {
+        return err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: RequestCredentialsErrorMessage.MissingOpenId4vpConfig
+        });
+    }
+    const {sessionUrl: sessionUrl} = session;
+    if (openId4VpRedirectUri) {
+        return await requestCredentialsSameDevice({
+            challenge: challenge,
+            apiBaseUrl: apiBaseUrl,
+            applicationId: applicationId,
+            sessionUrl: sessionUrl,
+            sessionKey: sessionKey,
+            sessionId: sessionId
+        });
+    }
+    return await requestCredentialsWithCrossDevice({
+        challenge: challenge,
+        apiBaseUrl: apiBaseUrl,
+        sessionUrl: sessionUrl,
+        sessionKey: sessionKey,
         sessionId: sessionId
     });
 };
 
-const requestCredentials = async options => {
-    var _a;
-    const initialiseOptions = getInitialiseOptions();
-    if (!initialiseOptions) {
-        throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+const deriveOpenId4vpRedirectUri = openid4vpConfiguration => {
+    if (!openid4vpConfiguration) {
+        return undefined;
     }
-    assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
-    const {challenge: challenge = generateChallenge()} = options;
-    const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : isMobileDetect(navigator.userAgent) ? exports.Mode.sameDevice : exports.Mode.crossDevice;
-    if (mode === exports.Mode.sameDevice && "redirectUri" in options) {
-        return await requestCredentialsSameDevice(Object.assign(Object.assign({}, options), {
-            initialiseOptions: initialiseOptions,
-            challenge: challenge,
-            mode: mode
-        }));
+    let detectedMode;
+    if (openid4vpConfiguration && openid4vpConfiguration.mode) {
+        detectedMode = openid4vpConfiguration.mode;
+    } else {
+        detectedMode = isMobileDetect(navigator.userAgent) ? exports.Mode.SameDevice : exports.Mode.CrossDevice;
     }
-    if (mode === exports.Mode.crossDevice && "crossDeviceCallback" in options) {
-        return await requestCredentialsCrossDevice(Object.assign(Object.assign({}, options), {
-            initialiseOptions: initialiseOptions,
-            challenge: challenge,
-            mode: mode
-        }));
+    if (detectedMode === exports.Mode.SameDevice && !isType(OpenId4vpConfigCrossDeviceOptionsValidator)(openid4vpConfiguration) && openid4vpConfiguration.redirectUri) {
+        return openid4vpConfiguration.redirectUri;
     }
-    throw new Exception("Invalid request credential options", {
-        data: options
-    });
+    return undefined;
 };
 
 exports.HandleRedirectCallbackErrorType = void 0;
@@ -1856,7 +2257,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 = {}));
 
@@ -1873,18 +2274,12 @@ const handleRedirectCallback = async () => {
             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({
@@ -1901,20 +2296,25 @@ const handleRedirectCallback = async () => {
         });
     }
     return ok({
-        result: result.value,
+        result: "challenge" in result.value ? result.value : undefined,
         sessionId: result.value.sessionId
     });
 };
 
 const utils = {
     generateChallenge: generateChallenge,
+    getVersion: getVersion,
     unwrap: unwrap
 };
 
+exports.abortCredentialRequest = abortCredentialRequest;
+
 exports.handleRedirectCallback = handleRedirectCallback;
 
 exports.initialise = initialise;
 
+exports.isDigitalCredentialsApiSupported = isDigitalCredentialsApiSupported;
+
 exports.requestCredentials = requestCredentials;
 
 exports.utils = utils;