@mattrglobal/verifier-sdk-web 2.3.1-unstable.3 → 2.3.1-unstable.32

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

@@ -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.
+ *
+ * @ignore - Internal method
+ */
+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,7 +7,7 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2026-08-19
+ * Generated: 2026-10-12
  * Version: 2.3.0
  * Dependencies:
  *
@@ -1350,12 +1350,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 +1623,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 +2082,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 +2192,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 +2201,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()) {