@mattrglobal/verifier-sdk-web 2.1.2-unstable.99 → 2.2.0

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

@@ -7,8 +7,8 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2026-03-17
- * Version: 2.1.1
+ * Generated: 2026-06-08
+ * Version: 2.2.0
  * Dependencies:
  */
 
@@ -181,7 +181,8 @@ const PresentationResultRelaxValidator = v__namespace.object({
     credentialQuery: v__namespace.optional(v__namespace.unknown()),
     credentials: v__namespace.optional(v__namespace.unknown()),
     credentialErrors: v__namespace.optional(v__namespace.unknown()),
-    error: v__namespace.optional(v__namespace.unknown())
+    error: v__namespace.optional(v__namespace.unknown()),
+    state: v__namespace.optional(v__namespace.string())
 });
 
 exports.Mode = void 0;
@@ -203,7 +204,8 @@ v__namespace.object({
     challenge: v__namespace.string(),
     redirectUri: v__namespace.optional(v__namespace.string()),
     walletProviderId: v__namespace.optional(v__namespace.string()),
-    dcApiSupported: v__namespace.optional(v__namespace.boolean())
+    dcApiSupported: v__namespace.optional(v__namespace.boolean()),
+    state: v__namespace.optional(v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1)))
 });
 
 const CreateSessionDigitalCredentialsValidator = v__namespace.object({
@@ -218,7 +220,8 @@ const CreateSessionOpenId4vpResponseValidator = v__namespace.object({
     type: v__namespace.optional(v__namespace.literal(SessionType.Openid4vp)),
     sessionId: v__namespace.string(),
     sessionKey: v__namespace.string(),
-    sessionUrl: v__namespace.string()
+    sessionUrl: v__namespace.string(),
+    state: v__namespace.optional(v__namespace.string())
 });
 
 const CreateSessionResponseValidator = v__namespace.union([ CreateSessionDigitalCredentialsValidator, CreateSessionOpenId4vpResponseValidator ]);
@@ -246,11 +249,12 @@ var LocalStorageKey;
 (function(LocalStorageKey) {
     LocalStorageKey["challenge"] = "mattr_chg";
     LocalStorageKey["sessionId"] = "mattr_sid";
+    LocalStorageKey["state"] = "mattr_st";
 })(LocalStorageKey || (LocalStorageKey = {}));
 
 const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
 
-const MATTR_SDK_VERSION_VALUE = "2.1.1";
+const MATTR_SDK_VERSION_VALUE = "2.2.0";
 
 var MessageEventDataType;
 
@@ -280,7 +284,8 @@ const OpenId4vpConfigAutoDetectOptionsValidator = v__namespace.object({
 const RequestCredentialsOptionsValidator = v__namespace.object({
     credentialQuery: v__namespace.pipe(v__namespace.array(CredentialQueryValidator), v__namespace.nonEmpty()),
     challenge: v__namespace.optional(v__namespace.string()),
-    openid4vpConfiguration: v__namespace.optional(v__namespace.union([ OpenId4vpConfigSameDeviceOptionsValidator, OpenId4vpConfigCrossDeviceOptionsValidator, OpenId4vpConfigAutoDetectOptionsValidator ]))
+    openid4vpConfiguration: v__namespace.optional(v__namespace.union([ OpenId4vpConfigSameDeviceOptionsValidator, OpenId4vpConfigCrossDeviceOptionsValidator, OpenId4vpConfigAutoDetectOptionsValidator ])),
+    state: v__namespace.optional(v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "state must not be empty")))
 });
 
 exports.RequestCredentialsErrorType = void 0;
@@ -303,6 +308,7 @@ var RequestCredentialsErrorMessage;
     RequestCredentialsErrorMessage["DcApiResponseParseError"] = "Failed to parse response from Digital Credentials API";
     RequestCredentialsErrorMessage["Abort"] = "User aborted the session";
     RequestCredentialsErrorMessage["Timeout"] = "User session timeout";
+    RequestCredentialsErrorMessage["StateMismatch"] = "State mismatch between requested session and back-channel result";
 })(RequestCredentialsErrorMessage || (RequestCredentialsErrorMessage = {}));
 
 exports.AbortSessionErrorType = void 0;
@@ -492,18 +498,20 @@ const getHashParamValue = (hash, param) => {
     return urlParams.get(param);
 };
 
-const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId, dcApiSupported: dcApiSupported, applicationId: applicationId}) => {
+const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId, dcApiSupported: dcApiSupported, applicationId: applicationId, state: state}) => {
     const openid4vpConfiguration = !!walletProviderId || !!redirectUri ? {
         redirectUri: redirectUri,
         walletProviderId: walletProviderId
     } : undefined;
-    const postData = {
+    const postData = Object.assign({
         credentialQuery: credentialQuery,
         challenge: challenge,
         applicationId: applicationId,
         dcApiSupported: dcApiSupported,
         openid4vpConfiguration: openid4vpConfiguration
-    };
+    }, state !== undefined ? {
+        state: state
+    } : {});
     const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/web/sessions`, {
         method: "POST",
         headers: {
@@ -621,7 +629,7 @@ const closeCrossDeviceModal = options => {
 };
 
 const receiveMessageHandler = options => async event => {
-    const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge} = options;
+    const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge, state: state} = options;
     if (event.origin !== apiBaseUrl) {
         return;
     }
@@ -643,10 +651,22 @@ const receiveMessageHandler = options => async event => {
             });
             return;
         }
+        const resultState = "challenge" in result.value ? result.value.state : undefined;
+        if (state !== undefined && resultState !== undefined && state !== resultState) {
+            onFailure({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.StateMismatch
+            });
+            closeCrossDeviceModal({
+                container: container
+            });
+            return;
+        }
         onComplete({
             result: "challenge" in result.value ? result.value : undefined,
             sessionId: result.value.sessionId,
-            sessionCompletedInRedirect: false
+            sessionCompletedInRedirect: false,
+            state: resultState !== null && resultState !== void 0 ? resultState : state
         });
         closeCrossDeviceModal({
             container: container
@@ -692,7 +712,7 @@ const openCrossDeviceModal = options => {
 };
 
 const requestCredentialsWithCrossDevice = async options => {
-    const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey} = options;
+    const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey, state: state} = options;
     const container = openCrossDeviceModal({
         sessionUrl: sessionUrl
     });
@@ -716,6 +736,7 @@ const requestCredentialsWithCrossDevice = async options => {
             sessionId: sessionId,
             apiBaseUrl: apiBaseUrl,
             challenge: challenge,
+            state: state,
             onComplete: data => resolve(neverthrow.ok(data)),
             onFailure: error => resolve(neverthrow.err(error))
         });
@@ -903,13 +924,18 @@ var SameDeviceRequestCredentialsErrorMessage;
 })(SameDeviceRequestCredentialsErrorMessage || (SameDeviceRequestCredentialsErrorMessage = {}));
 
 const requestCredentialsSameDevice = async options => {
-    const {challenge: challenge, apiBaseUrl: apiBaseUrl, applicationId: applicationId, sessionUrl: sessionUrl, sessionKey: sessionKey, sessionId: sessionId} = options;
+    const {challenge: challenge, apiBaseUrl: apiBaseUrl, applicationId: applicationId, sessionUrl: sessionUrl, sessionKey: sessionKey, sessionId: sessionId, state: state} = options;
     const abortController = setActiveSession({
         sessionId: sessionId,
         sessionKey: sessionKey
     });
     window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
     window.localStorage.setItem(LocalStorageKey.challenge, challenge);
+    if (state !== undefined) {
+        window.localStorage.setItem(LocalStorageKey.state, state);
+    } else {
+        window.localStorage.removeItem(LocalStorageKey.state);
+    }
     window.location.assign(sessionUrl);
     await sleep(SESSION_STATUS_POLLING_INITIAL_DELAY_MS);
     const checkResult = await withRetry((async () => {
@@ -960,7 +986,7 @@ const requestCredentials = async options => {
     }
     assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
     const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initializeOptions;
-    const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration} = options;
+    const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration, state: state} = options;
     const dcApiSupported = isDigitalCredentialsApiSupported();
     const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
     const createSessionResult = await createSession({
@@ -970,7 +996,8 @@ const requestCredentials = async options => {
         walletProviderId: (_a = openid4vpConfiguration === null || openid4vpConfiguration === void 0 ? void 0 : openid4vpConfiguration.walletProviderId) !== null && _a !== void 0 ? _a : undefined,
         apiBaseUrl: apiBaseUrl,
         applicationId: applicationId,
-        dcApiSupported: dcApiSupported
+        dcApiSupported: dcApiSupported,
+        state: state
     });
     if (createSessionResult.isErr()) {
         return neverthrow.err({
@@ -1006,7 +1033,8 @@ const requestCredentials = async options => {
             applicationId: applicationId,
             sessionUrl: sessionUrl,
             sessionKey: sessionKey,
-            sessionId: sessionId
+            sessionId: sessionId,
+            state: state
         });
     }
     return await requestCredentialsWithCrossDevice({
@@ -1014,7 +1042,8 @@ const requestCredentials = async options => {
         apiBaseUrl: apiBaseUrl,
         sessionUrl: sessionUrl,
         sessionKey: sessionKey,
-        sessionId: sessionId
+        sessionId: sessionId,
+        state: state
     });
 };
 
@@ -1047,9 +1076,11 @@ var HandleRedirectCallbackErrorMessage;
     HandleRedirectCallbackErrorMessage["FailedToFindChallenge"] = "Failed to find challenge";
     HandleRedirectCallbackErrorMessage["FailedToFindActiveSession"] = "Failed to find active session";
     HandleRedirectCallbackErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
+    HandleRedirectCallbackErrorMessage["StateMismatch"] = "State mismatch between stored session and back-channel result";
 })(HandleRedirectCallbackErrorMessage || (HandleRedirectCallbackErrorMessage = {}));
 
 const handleRedirectCallback = async () => {
+    var _a;
     const initializeOptions = getInitializeOptions();
     if (!initializeOptions) {
         throw new Exception(InitializeErrorMessage.SdkNotInitialized);
@@ -1064,6 +1095,7 @@ const handleRedirectCallback = async () => {
     }
     const sessionId = window.localStorage.getItem(LocalStorageKey.sessionId);
     const challenge = window.localStorage.getItem(LocalStorageKey.challenge);
+    const storedState = (_a = window.localStorage.getItem(LocalStorageKey.state)) !== null && _a !== void 0 ? _a : undefined;
     if (!sessionId || !challenge) {
         return neverthrow.err({
             type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
@@ -1083,9 +1115,22 @@ const handleRedirectCallback = async () => {
             cause: result.error
         });
     }
+    const resultState = "challenge" in result.value ? result.value.state : undefined;
+    if (storedState !== undefined && resultState !== undefined && storedState !== resultState) {
+        window.localStorage.removeItem(LocalStorageKey.challenge);
+        window.localStorage.removeItem(LocalStorageKey.sessionId);
+        window.localStorage.removeItem(LocalStorageKey.state);
+        return neverthrow.err({
+            type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
+            message: HandleRedirectCallbackErrorMessage.StateMismatch
+        });
+    }
+    const state = resultState !== null && resultState !== void 0 ? resultState : storedState;
+    window.localStorage.removeItem(LocalStorageKey.state);
     return neverthrow.ok({
         result: "challenge" in result.value ? result.value : undefined,
-        sessionId: result.value.sessionId
+        sessionId: result.value.sessionId,
+        state: state
     });
 };