@mattrglobal/verifier-sdk-web 2.3.1-unstable.4 → 2.3.1-unstable.41

package/dist/typings/verifier/requestCredentialsDigitalCredentialsApi.d.ts

@@ -5,7 +5,7 @@ import { RequestCredentialsErrorType, RequestCredentialsResponse, RequestCredent
  * Request credentials for the Digital Credentials API
  *
  * @param options - {@link RequestCredentialsWithDcApiOptions}
- * @ignore - Internal method
+ * @internal
  */
 export declare const requestCredentialsWithDigitalCredentialsApi: (options: RequestCredentialsWithDcApiOptions) => Promise<Result<RequestCredentialsResponse, BaseError<RequestCredentialsErrorType.RequestCredentialsFailed>>>;
 /**
@@ -14,6 +14,17 @@ export declare const requestCredentialsWithDigitalCredentialsApi: (options: Requ
  *
  * Checks if Digital Credentials API feature is supported for the current browser.
  *
- * @returns boolean.
+ * @returns boolean
  */
 export declare const isDigitalCredentialsApiSupported: () => boolean;
+export type DigitalCredentialsApiSupport = {
+    supported: boolean;
+    /** MATTR VII & browser supported protocols */
+    protocols?: string[];
+};
+/**
+ * Determines DC-API support for the current browser, narrowed to the protocols it accepts.
+ *
+ * @internal
+ */
+export declare const getDigitalCredentialsApiSupport: (apiBaseUrl: string) => Promise<DigitalCredentialsApiSupport>;

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

@@ -329,6 +329,18 @@ export type RequestCredentialsWithDcApiOptions = {
     challenge: string;
     request: Record<string, unknown>;
 };
+export type VerifierConfiguration = v.InferOutput<typeof VerifierConfigurationValidator>;
+export declare const VerifierConfigurationValidator: v.ObjectSchema<{
+    readonly dcApi: v.ObjectSchema<{
+        /**
+         * DC-API protocols that MATTR VII supports.
+         *
+         * Typed as plain strings rather than a known strict set, since the list is fetched from MATTR VII
+         * at runtime and a fixed set here could introduce version mismatches between an SDK release
+         */
+        readonly protocols: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
 export type CreateSessionRequest = v.InferOutput<typeof CreateSessionRequestValidator>;
 export declare const CreateSessionRequestValidator: v.ObjectSchema<{
     readonly credentialQuery: v.ArraySchema<v.ObjectSchema<{
@@ -341,7 +353,15 @@ export declare const CreateSessionRequestValidator: v.ObjectSchema<{
     readonly challenge: v.StringSchema<undefined>;
     readonly redirectUri: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /** Indicates if DC-API is supported in the browser */
     readonly dcApiSupported: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    /**
+     * DC-API request protocols that MATTR VII supports & the browser accepts.
+     *
+     * Typed as plain strings rather than a known strict set, since the list is fetched from MATTR VII
+     * at runtime and a fixed set here could introduce version mismatches between an SDK release
+     */
+    readonly dcApiProtocols: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly state: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
 }, undefined>;
 export type CreateSessionResponse = v.InferOutput<typeof CreateSessionResponseValidator>;

package/dist/typings/verifier/utils.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
 import { SafeFetchValidateResponseError } from "../common/safeFetch";
-import { CreateSessionRequest, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitializeOptions, CreateSessionResponse } from "./types";
+import { CreateSessionRequest, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitializeOptions, CreateSessionResponse, VerifierConfiguration } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -15,6 +15,14 @@ export declare const generateChallenge: () => string;
  * @returns The value of the specified parameter, or null if the parameter is not found.
  */
 export declare const getHashParamValue: (hash: string, param: string) => string | null;
+/**
+ * Fetches the verifier configuration MATTR VII advertises, including the DC-API protocols it
+ * can serve.
+ *
+ * @param uri - The base URL of the API.
+ * @returns A promise that resolves to a result containing either the verifier configuration or an error.
+ */
+export declare const getVerifierConfiguration: (uri: string) => Promise<Result<VerifierConfiguration, SafeFetchValidateResponseError>>;
 /**
  * Creates a new session with the provided parameters.
  *
@@ -26,7 +34,7 @@ export declare const getHashParamValue: (hash: string, param: string) => string
  * @param walletProviderId - optional, The ID of the wallet provider, if not provided the default wallet provider will be used.
  * @returns A promise that resolves to a result containing either the created session response or an error.
  */
-export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, dcApiSupported, applicationId, state, }: CreateSessionRequest & InitializeOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateResponseError>>;
+export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, dcApiSupported, dcApiProtocols, applicationId, state, }: CreateSessionRequest & InitializeOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateResponseError>>;
 /**
  * Abort a session with the provided parameters.
  *

package/dist/verifier-js.development.js

@@ -7,13 +7,13 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2026-08-19
+ * Generated: 2026-11-05
  * Version: 2.3.0
  * Dependencies:
  *
  * neverthrow -- 4.3.0
  *
- * valibot -- 1.2.0
+ * valibot -- 1.4.2
  *
  * is-mobile -- 4.0.0
  */
@@ -547,8 +547,15 @@
         }
     }
     var store$4;
+    var DEFAULT_CONFIG = {
+        lang: void 0,
+        message: void 0,
+        abortEarly: void 0,
+        abortPipeEarly: void 0
+    };
     function getGlobalConfig(config$1) {
         var _config$1$lang, _store$, _config$1$abortEarly, _store$2, _config$1$abortPipeEa, _store$3;
+        if (!config$1 && !store$4) return DEFAULT_CONFIG;
         return {
             lang: (_config$1$lang = config$1 === null || config$1 === void 0 ? void 0 : config$1.lang) !== null && _config$1$lang !== void 0 ? _config$1$lang : (_store$ = store$4) === null || _store$ === void 0 ? void 0 : _store$.lang,
             message: config$1 === null || config$1 === void 0 ? void 0 : config$1.message,
@@ -604,19 +611,25 @@
         if (isSchema) dataset.typed = false;
         if (dataset.issues) dataset.issues.push(issue); else dataset.issues = [ issue ];
     }
+    var _standardCache = new WeakMap;
     function _getStandardProps(context) {
-        return {
-            version: 1,
-            vendor: "valibot",
-            validate: function validate(value$1) {
-                return context["~run"]({
-                    value: value$1
-                }, getGlobalConfig());
-            }
-        };
+        var cached = _standardCache.get(context);
+        if (!cached) {
+            cached = {
+                version: 1,
+                vendor: "valibot",
+                validate: function validate(value$1) {
+                    return context["~run"]({
+                        value: value$1
+                    }, getGlobalConfig());
+                }
+            };
+            _standardCache.set(context, cached);
+        }
+        return cached;
     }
     function _isValidObjectKey(object$1, key) {
-        return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+        return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
     }
     function _joinExpects(values$1, separator) {
         var _list$;
@@ -731,18 +744,18 @@
                                 key: key,
                                 value: value$1
                             };
-                            var _iterator15 = _createForOfIteratorHelper(itemDataset.issues), _step15;
+                            var _iterator16 = _createForOfIteratorHelper(itemDataset.issues), _step16;
                             try {
-                                for (_iterator15.s(); !(_step15 = _iterator15.n()).done; ) {
+                                for (_iterator16.s(); !(_step16 = _iterator16.n()).done; ) {
                                     var _dataset$issues;
-                                    var issue = _step15.value;
+                                    var issue = _step16.value;
                                     if (issue.path) issue.path.unshift(pathItem); else issue.path = [ pathItem ];
                                     (_dataset$issues = dataset.issues) === null || _dataset$issues === void 0 || _dataset$issues.push(issue);
                                 }
                             } catch (err) {
-                                _iterator15.e(err);
+                                _iterator16.e(err);
                             } finally {
-                                _iterator15.f();
+                                _iterator16.f();
                             }
                             if (!dataset.issues) dataset.issues = itemDataset.issues;
                             if (config$1.abortEarly) {
@@ -842,18 +855,18 @@
                                     key: key,
                                     value: value$1
                                 };
-                                var _iterator31 = _createForOfIteratorHelper(valueDataset.issues), _step31;
+                                var _iterator34 = _createForOfIteratorHelper(valueDataset.issues), _step34;
                                 try {
-                                    for (_iterator31.s(); !(_step31 = _iterator31.n()).done; ) {
-                                        var _dataset$issues13;
-                                        var issue = _step31.value;
+                                    for (_iterator34.s(); !(_step34 = _iterator34.n()).done; ) {
+                                        var _dataset$issues11;
+                                        var issue = _step34.value;
                                         if (issue.path) issue.path.unshift(pathItem); else issue.path = [ pathItem ];
-                                        (_dataset$issues13 = dataset.issues) === null || _dataset$issues13 === void 0 || _dataset$issues13.push(issue);
+                                        (_dataset$issues11 = dataset.issues) === null || _dataset$issues11 === void 0 || _dataset$issues11.push(issue);
                                     }
                                 } catch (err) {
-                                    _iterator31.e(err);
+                                    _iterator34.e(err);
                                 } finally {
-                                    _iterator31.f();
+                                    _iterator34.f();
                                 }
                                 if (!dataset.issues) dataset.issues = valueDataset.issues;
                                 if (config$1.abortEarly) {
@@ -956,18 +969,18 @@
                                 key: entryKey,
                                 value: entryValue
                             };
-                            var _iterator40 = _createForOfIteratorHelper(keyDataset.issues), _step40;
+                            var _iterator43 = _createForOfIteratorHelper(keyDataset.issues), _step43;
                             try {
-                                for (_iterator40.s(); !(_step40 = _iterator40.n()).done; ) {
-                                    var _dataset$issues19;
-                                    var issue = _step40.value;
+                                for (_iterator43.s(); !(_step43 = _iterator43.n()).done; ) {
+                                    var _dataset$issues17;
+                                    var issue = _step43.value;
                                     issue.path = [ pathItem ];
-                                    (_dataset$issues19 = dataset.issues) === null || _dataset$issues19 === void 0 || _dataset$issues19.push(issue);
+                                    (_dataset$issues17 = dataset.issues) === null || _dataset$issues17 === void 0 || _dataset$issues17.push(issue);
                                 }
                             } catch (err) {
-                                _iterator40.e(err);
+                                _iterator43.e(err);
                             } finally {
-                                _iterator40.f();
+                                _iterator43.f();
                             }
                             if (!dataset.issues) dataset.issues = keyDataset.issues;
                             if (config$1.abortEarly) {
@@ -986,18 +999,18 @@
                                 key: entryKey,
                                 value: entryValue
                             };
-                            var _iterator41 = _createForOfIteratorHelper(valueDataset.issues), _step41;
+                            var _iterator44 = _createForOfIteratorHelper(valueDataset.issues), _step44;
                             try {
-                                for (_iterator41.s(); !(_step41 = _iterator41.n()).done; ) {
-                                    var _dataset$issues20;
-                                    var _issue5 = _step41.value;
+                                for (_iterator44.s(); !(_step44 = _iterator44.n()).done; ) {
+                                    var _dataset$issues18;
+                                    var _issue5 = _step44.value;
                                     if (_issue5.path) _issue5.path.unshift(_pathItem5); else _issue5.path = [ _pathItem5 ];
-                                    (_dataset$issues20 = dataset.issues) === null || _dataset$issues20 === void 0 || _dataset$issues20.push(_issue5);
+                                    (_dataset$issues18 = dataset.issues) === null || _dataset$issues18 === void 0 || _dataset$issues18.push(_issue5);
                                 }
                             } catch (err) {
-                                _iterator41.e(err);
+                                _iterator44.e(err);
                             } finally {
-                                _iterator41.f();
+                                _iterator44.f();
                             }
                             if (!dataset.issues) dataset.issues = valueDataset.issues;
                             if (config$1.abortEarly) {
@@ -1045,18 +1058,18 @@
                                     key: key,
                                     value: value$1
                                 };
-                                var _iterator49 = _createForOfIteratorHelper(valueDataset.issues), _step49;
+                                var _iterator52 = _createForOfIteratorHelper(valueDataset.issues), _step52;
                                 try {
-                                    for (_iterator49.s(); !(_step49 = _iterator49.n()).done; ) {
-                                        var _dataset$issues25;
-                                        var issue = _step49.value;
+                                    for (_iterator52.s(); !(_step52 = _iterator52.n()).done; ) {
+                                        var _dataset$issues23;
+                                        var issue = _step52.value;
                                         if (issue.path) issue.path.unshift(pathItem); else issue.path = [ pathItem ];
-                                        (_dataset$issues25 = dataset.issues) === null || _dataset$issues25 === void 0 || _dataset$issues25.push(issue);
+                                        (_dataset$issues23 = dataset.issues) === null || _dataset$issues23 === void 0 || _dataset$issues23.push(issue);
                                     }
                                 } catch (err) {
-                                    _iterator49.e(err);
+                                    _iterator52.e(err);
                                 } finally {
-                                    _iterator49.f();
+                                    _iterator52.f();
                                 }
                                 if (!dataset.issues) dataset.issues = valueDataset.issues;
                                 if (config$1.abortEarly) {
@@ -1122,17 +1135,28 @@
     function _subIssues(datasets) {
         var issues;
         if (datasets) {
-            var _iterator64 = _createForOfIteratorHelper(datasets), _step64;
+            var _iterator67 = _createForOfIteratorHelper(datasets), _step67;
             try {
-                for (_iterator64.s(); !(_step64 = _iterator64.n()).done; ) {
-                    var _issues;
-                    var dataset = _step64.value;
-                    if (issues) (_issues = issues).push.apply(_issues, _toConsumableArray(dataset.issues)); else issues = dataset.issues;
+                for (_iterator67.s(); !(_step67 = _iterator67.n()).done; ) {
+                    var dataset = _step67.value;
+                    if (issues) {
+                        var _iterator68 = _createForOfIteratorHelper(dataset.issues), _step68;
+                        try {
+                            for (_iterator68.s(); !(_step68 = _iterator68.n()).done; ) {
+                                var issue = _step68.value;
+                                issues.push(issue);
+                            }
+                        } catch (err) {
+                            _iterator68.e(err);
+                        } finally {
+                            _iterator68.f();
+                        }
+                    } else issues = dataset.issues;
                 }
             } catch (err) {
-                _iterator64.e(err);
+                _iterator67.e(err);
             } finally {
-                _iterator64.f();
+                _iterator67.f();
             }
         }
         return issues;
@@ -1156,10 +1180,10 @@
                 var validDataset;
                 var typedDatasets;
                 var untypedDatasets;
-                var _iterator65 = _createForOfIteratorHelper(this.options), _step65;
+                var _iterator69 = _createForOfIteratorHelper(this.options), _step69;
                 try {
-                    for (_iterator65.s(); !(_step65 = _iterator65.n()).done; ) {
-                        var schema = _step65.value;
+                    for (_iterator69.s(); !(_step69 = _iterator69.n()).done; ) {
+                        var schema = _step69.value;
                         var optionDataset = schema["~run"]({
                             value: dataset.value
                         }, config$1);
@@ -1173,9 +1197,9 @@
                         } else if (untypedDatasets) untypedDatasets.push(optionDataset); else untypedDatasets = [ optionDataset ];
                     }
                 } catch (err) {
-                    _iterator65.e(err);
+                    _iterator69.e(err);
                 } finally {
-                    _iterator65.f();
+                    _iterator69.f();
                 }
                 if (validDataset) return validDataset;
                 if (typedDatasets) {
@@ -1350,12 +1374,18 @@
         SessionType["DigitalCredentialsApi"] = "digital-credentials-api";
         SessionType["Openid4vp"] = "openid4vp";
     })(SessionType || (SessionType = {}));
+    const VerifierConfigurationValidator = object({
+        dcApi: object({
+            protocols: array(string())
+        })
+    });
     object({
         credentialQuery: array(CredentialQueryValidator),
         challenge: string(),
         redirectUri: optional(string()),
         walletProviderId: optional(string()),
         dcApiSupported: optional(_boolean()),
+        dcApiProtocols: optional(array(string())),
         state: optional(pipe(string(), minLength(1)))
     });
     const CreateSessionDigitalCredentialsValidator = object({
@@ -1617,18 +1647,40 @@
         const urlParams = new URLSearchParams(hash.split("#")[1]);
         return urlParams.get(param);
     };
-    const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId, dcApiSupported: dcApiSupported, applicationId: applicationId, state: state}) => {
+    const getVerifierConfiguration = async uri => {
+        const responseResult = await safeFetch(`${uri}/v2/presentations/web/configuration`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        const body = await responseResult.value.json().catch((() => undefined));
+        if (!isType(VerifierConfigurationValidator)(body)) {
+            return err({
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+                message: "Verifier configuration returned unsupported response"
+            });
+        }
+        return ok(body);
+    };
+    const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId, dcApiSupported: dcApiSupported, dcApiProtocols: dcApiProtocols, applicationId: applicationId, state: state}) => {
         const openid4vpConfiguration = !!walletProviderId || !!redirectUri ? {
             redirectUri: redirectUri,
             walletProviderId: walletProviderId
         } : undefined;
-        const postData = Object.assign({
+        const postData = Object.assign(Object.assign(Object.assign({
             credentialQuery: credentialQuery,
             challenge: challenge,
             applicationId: applicationId,
-            dcApiSupported: dcApiSupported,
+            dcApiSupported: dcApiSupported
+        }, dcApiProtocols !== undefined ? {
+            dcApiProtocols: dcApiProtocols
+        } : {}), {
             openid4vpConfiguration: openid4vpConfiguration
-        }, state !== undefined ? {
+        }), state !== undefined ? {
             state: state
         } : {});
         const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/web/sessions`, {
@@ -2054,9 +2106,43 @@
         }
         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 digitalCredentialsApiSupported = target => {
+        var _a, _b;
+        return "DigitalCredential" in target && typeof ((_b = (_a = target.navigator) === null || _a === void 0 ? void 0 : _a.credentials) === null || _b === void 0 ? void 0 : _b.get) === "function" && typeof target.DigitalCredential === "function" && (!("userAgentAllowsProtocol" in target.DigitalCredential) || typeof target.DigitalCredential.userAgentAllowsProtocol === "function");
+    };
+    const isDigitalCredentialsApiSupported = () => digitalCredentialsApiSupported(window);
+    const getDigitalCredentialsApiSupport = async apiBaseUrl => {
+        if (!digitalCredentialsApiSupported(window)) {
+            return {
+                supported: false
+            };
+        }
+        const {DigitalCredential: digitalCredential} = window;
+        if (!digitalCredential.userAgentAllowsProtocol) {
+            return {
+                supported: true
+            };
+        }
+        const configurationResult = await getVerifierConfiguration(apiBaseUrl);
+        if (configurationResult.isErr()) {
+            return {
+                supported: true
+            };
+        }
+        const protocols = configurationResult.value.dcApi.protocols.filter((protocol => {
+            var _a;
+            try {
+                return ((_a = digitalCredential.userAgentAllowsProtocol) === null || _a === void 0 ? void 0 : _a.call(digitalCredential, protocol)) === true;
+            } catch (_b) {
+                return false;
+            }
+        }));
+        return protocols.length > 0 ? {
+            supported: true,
+            protocols: protocols
+        } : {
+            supported: false
+        };
     };
     const sleep = ms => new Promise((resolve => setTimeout(resolve, ms)));
     const SESSION_STATUS_POLLING_MAX_RETRY = 1e3;
@@ -2130,7 +2216,7 @@
         assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
         const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initializeOptions;
         const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration, state: state, onPresentationRequest: onPresentationRequest} = options;
-        const dcApiSupported = isDigitalCredentialsApiSupported();
+        const dcApiSupport = await getDigitalCredentialsApiSupport(apiBaseUrl);
         const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
         const createSessionResult = await createSession({
             credentialQuery: credentialQuery,
@@ -2139,7 +2225,8 @@
             walletProviderId: (_a = openid4vpConfiguration === null || openid4vpConfiguration === void 0 ? void 0 : openid4vpConfiguration.walletProviderId) !== null && _a !== void 0 ? _a : undefined,
             apiBaseUrl: apiBaseUrl,
             applicationId: applicationId,
-            dcApiSupported: dcApiSupported,
+            dcApiSupported: dcApiSupport.supported,
+            dcApiProtocols: dcApiSupport.protocols,
             state: state
         });
         if (createSessionResult.isErr()) {