@mattrglobal/verifier-sdk-web 1.0.2-unstable.99 → 2.0.0-preview-digital-credential-api.1

package/dist/typings/index.d.ts

@@ -7,5 +7,6 @@ export type { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSa
 declare const utils: {
     generateChallenge: () => string;
     unwrap: <T = unknown>(result: import("neverthrow").Result<T, unknown>, errMessage?: string) => T;
+    isDigitalCredentialsApiSupported: () => boolean;
 };
 export { initialise, requestCredentials, handleRedirectCallback, utils };

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

@@ -0,0 +1,7 @@
+import { Result } from "neverthrow";
+import { RequestCredentialsError, DigitalCredentialsApiRequestOptions, DigitalCredentialsApiRequestCredentialsResponse } from "./types";
+export declare enum SameDeviceRequestCredentialsErrorMessage {
+    FailedToStoreChallenge = "Failed to store challenge",
+    FailedToCreateSession = "Failed to create session"
+}
+export declare const requestCredentialsDigitalCredentialsApi: (options: DigitalCredentialsApiRequestOptions) => Promise<Result<DigitalCredentialsApiRequestCredentialsResponse, RequestCredentialsError>>;

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

@@ -255,3 +255,11 @@ export declare const CreateSessionResponseValidator: v.ObjectSchema<{
     readonly sessionUrl: v.StringSchema<undefined>;
 }, undefined>;
 /*** session end ***/
+export type CreateDigitalCredentialsApiSessionResponse = {
+    sessionId: string;
+    request: any;
+};
+export declare const CreateDigitalCredentialsApiSessionResponseValidator: v.ObjectSchema<{
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly request: v.ObjectSchema<{}, undefined>;
+}, undefined>;

package/dist/typings/verifier/types/verifier-web-sdk.d.ts

@@ -61,6 +61,11 @@ export type CrossDeviceRequestCredentialsOptions = {
     mode: Mode.crossDevice;
     initialiseOptions: InitialiseOptions;
 };
+export type DigitalCredentialsApiRequestOptions = {
+    credentialQuery: CredentialQuery[];
+    challenge: string;
+    initialiseOptions: InitialiseOptions;
+};
 /**
  * Options for the same device requestCredentials function
  */
@@ -265,10 +270,17 @@ export type MessageEvent = {
 export type CrossDeviceRequestCredentialsResponse = {
     sessionId: string;
 };
+/**
+ * The response from the digital credentials api requestCredentials function
+ */
+export type DigitalCredentialsApiRequestCredentialsResponse = {
+    sessionId: string;
+    result: PresentationSessionResult;
+};
 /**
  * The response from the requestCredentials function
  */
-export type RequestCredentialsResponse = SameDeviceRequestCredentialsResponse | CrossDeviceRequestCredentialsResponse;
+export type RequestCredentialsResponse = SameDeviceRequestCredentialsResponse | CrossDeviceRequestCredentialsResponse | DigitalCredentialsApiRequestCredentialsResponse;
 /**
  * The error type for the requestCredentials function
  */
@@ -296,7 +308,11 @@ export type HandleRedirectCallbackResponse = {
  */
 export type InitialiseOptions = {
     apiBaseUrl: string;
+    enableDigitalCredentialsApiSameDeviceFlow?: boolean;
+    enableDigitalCredentialsApiCrossDeviceFlow?: boolean;
 };
 export declare const InitialiseOptionsValidator: v.ObjectSchema<{
     readonly apiBaseUrl: v.StringSchema<undefined>;
+    readonly enableDigitalCredentialsApiSameDeviceFlow: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+    readonly enableDigitalCredentialsApiCrossDeviceFlow: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
 }, undefined>;

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

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
 import { SafeFetchValidateRespondError } from "../common/safeFetch";
-import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse } from "./types";
+import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, CreateDigitalCredentialsApiSessionResponse } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -50,3 +50,35 @@ export declare const exchangeSessionResult: ({ challenge, responseCode, sessionI
  * @returns A boolean indicating whether the user agent is a mobile device.
  */
 export declare const isMobileDetect: (userAgent: string) => boolean;
+/**
+ * Detects if digital credentials api is available.
+ *
+ * @returns A boolean indicating whether the user agent supports the digital credential api.
+ */
+export declare const isDigitalCredentialsApiSupported: () => boolean;
+/**
+ * Creates a new digital credentials api session with the provided parameters.
+ *
+ * @param credentialQuery - The credential query for the session.
+ * @param challenge - The challenge for the session.
+ * @param apiBaseUrl - The base URL of the API.
+ * @returns A promise that resolves to a result containing either the created session response or an error.
+ */
+export declare const createDigitalCredentialsApiSession: ({ credentialQuery, challenge, apiBaseUrl, }: CreateSessionRequest & {
+    apiBaseUrl: string;
+}) => Promise<Result<CreateDigitalCredentialsApiSessionResponse, SafeFetchValidateRespondError>>;
+/**
+ * Retrieves the result of a session using the provided parameters.
+ *
+ * @param challenge - The challenge for the session.
+ * @param sessionId - The ID of the session.
+ * @param response - The response from the digital credentials api.
+ * @param apiBaseUrl - The base URL of the API.
+ * @returns A promise that resolves to a result containing either the session result response or an error.
+ */
+export declare const getDigitalCredentialsApiSessionResult: ({ challenge, sessionId, response, apiBaseUrl, }: {
+    challenge: string;
+    sessionId: string;
+    response: any;
+    apiBaseUrl: string;
+}) => Promise<Result<any, SafeFetchValidateRespondError>>;

package/dist/verifier-js.development.js

@@ -7,8 +7,8 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2024-10-20
- * Version: 1.0.1
+ * Generated: 2024-10-21
+ * Version: 2.0.0-preview-digital-credential-api.1
  * Dependencies:
  *
  * neverthrow -- 4.3.0
@@ -1332,6 +1332,10 @@
         sessionId: string(),
         sessionUrl: string()
     });
+    const CreateDigitalCredentialsApiSessionResponseValidator = object({
+        sessionId: string(),
+        request: object({})
+    });
     var LocalStorageKey;
     (function(LocalStorageKey) {
         LocalStorageKey["challenge"] = "mattr_chg";
@@ -1382,7 +1386,9 @@
         RequestCredentialsErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
     })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
     const InitialiseOptionsValidator = object({
-        apiBaseUrl: string()
+        apiBaseUrl: string(),
+        enableDigitalCredentialsApiSameDeviceFlow: optional(_boolean()),
+        enableDigitalCredentialsApiCrossDeviceFlow: optional(_boolean())
     });
     let initialiseOptions = undefined;
     var InitialiseErrorMessage;
@@ -1506,6 +1512,61 @@
         ua: userAgent,
         tablet: false
     });
+    const isDigitalCredentialsApiSupported = () => {
+        var _a;
+        try {
+            return typeof ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.identity) === null || _a === void 0 ? void 0 : _a.get) === "function";
+        } catch (error) {
+            return false;
+        }
+    };
+    const createDigitalCredentialsApiSession = async ({credentialQuery: credentialQuery, challenge: challenge, apiBaseUrl: apiBaseUrl}) => {
+        const postData = {
+            credentialQuery: credentialQuery,
+            challenge: challenge
+        };
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/browserApi/request`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(postData)
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        const data = await responseResult.value.json();
+        if (!isType(CreateDigitalCredentialsApiSessionResponseValidator)(data)) {
+            return err({
+                type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
+                message: "Create digital credentials api session return unsupported response"
+            });
+        }
+        return ok(data);
+    };
+    const getDigitalCredentialsApiSessionResult = async ({challenge: challenge, sessionId: sessionId, response: response, apiBaseUrl: apiBaseUrl}) => {
+        const postData = {
+            challenge: challenge,
+            sessionId: sessionId,
+            response: response
+        };
+        const fetchResultFn = async () => await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/browserApi/response`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(postData)
+        });
+        const responseResult = await withRetrySafeFetch(fetchResultFn, {
+            retries: 2,
+            retryHttpStatus: 404
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        const data = await responseResult.value.json();
+        return ok(data);
+    };
     exports.CrossDeviceCallbackErrorType = void 0;
     (function(CrossDeviceCallbackErrorType) {
         CrossDeviceCallbackErrorType["Timeout"] = "Timeout";
@@ -1635,11 +1696,11 @@
             sessionId: sessionId
         });
     };
-    var SameDeviceRequestCredentialsErrorMessage;
+    var SameDeviceRequestCredentialsErrorMessage$1;
     (function(SameDeviceRequestCredentialsErrorMessage) {
         SameDeviceRequestCredentialsErrorMessage["FailedToStoreChallenge"] = "Failed to store challenge";
         SameDeviceRequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
-    })(SameDeviceRequestCredentialsErrorMessage || (SameDeviceRequestCredentialsErrorMessage = {}));
+    })(SameDeviceRequestCredentialsErrorMessage$1 || (SameDeviceRequestCredentialsErrorMessage$1 = {}));
     const requestCredentialsSameDevice = async options => {
         const {challenge: challenge, credentialQuery: credentialQuery, redirectUri: redirectUri, walletProviderId: walletProviderId, initialiseOptions: initialiseOptions} = options;
         const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
@@ -1648,7 +1709,7 @@
         if (!storedChallenge) {
             return err({
                 type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
+                message: SameDeviceRequestCredentialsErrorMessage$1.FailedToStoreChallenge
             });
         }
         const createSessionResult = await createSession({
@@ -1661,7 +1722,7 @@
         if (createSessionResult.isErr()) {
             return err({
                 type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+                message: SameDeviceRequestCredentialsErrorMessage$1.FailedToCreateSession,
                 cause: createSessionResult.error
             });
         }
@@ -1672,6 +1733,68 @@
             sessionId: sessionId
         });
     };
+    var SameDeviceRequestCredentialsErrorMessage;
+    (function(SameDeviceRequestCredentialsErrorMessage) {
+        SameDeviceRequestCredentialsErrorMessage["FailedToStoreChallenge"] = "Failed to store challenge";
+        SameDeviceRequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
+    })(SameDeviceRequestCredentialsErrorMessage || (SameDeviceRequestCredentialsErrorMessage = {}));
+    const requestCredentialsDigitalCredentialsApi = async options => {
+        const {challenge: challenge, credentialQuery: credentialQuery, initialiseOptions: initialiseOptions} = options;
+        const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
+        window.localStorage.setItem(LocalStorageKey.challenge, challenge);
+        const storedChallenge = window.localStorage.getItem(LocalStorageKey.challenge);
+        if (!storedChallenge) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
+            });
+        }
+        const createSessionResult = await createDigitalCredentialsApiSession({
+            credentialQuery: credentialQuery,
+            challenge: storedChallenge,
+            apiBaseUrl: apiBaseUrl
+        });
+        if (createSessionResult.isErr()) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: SameDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+                cause: createSessionResult.error
+            });
+        }
+        const {request: request, sessionId: sessionId} = createSessionResult.value;
+        window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
+        let rawResponse;
+        try {
+            rawResponse = await navigator.identity.get(request);
+        } catch (_a) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: "Failed call to digital credentials api"
+            });
+        }
+        let response;
+        try {
+            response = JSON.parse(rawResponse.data);
+        } catch (_b) {
+            response = rawResponse.data;
+        }
+        const result = await getDigitalCredentialsApiSessionResult({
+            challenge: challenge,
+            sessionId: sessionId,
+            response: response,
+            apiBaseUrl: apiBaseUrl
+        });
+        if (result.isOk()) {
+            return ok({
+                sessionId: sessionId,
+                result: result.value
+            });
+        }
+        return err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: "Invalid response from digital credentials api"
+        });
+    };
     const requestCredentials = async options => {
         var _a;
         const initialiseOptions = getInitialiseOptions();
@@ -1681,6 +1804,24 @@
         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 (initialiseOptions.enableDigitalCredentialsApiCrossDeviceFlow && isDigitalCredentialsApiSupported() && mode === exports.Mode.crossDevice) {
+            console.log("Digital Credentials API support found, proceeding with request using API in cross device flow");
+            return await requestCredentialsDigitalCredentialsApi(Object.assign(Object.assign({}, options), {
+                initialiseOptions: initialiseOptions,
+                challenge: challenge
+            }));
+        } else if (initialiseOptions.enableDigitalCredentialsApiCrossDeviceFlow) {
+            console.log("Digital Credentials API support not found, falling back to OpenID4VP");
+        }
+        if (initialiseOptions.enableDigitalCredentialsApiSameDeviceFlow && isDigitalCredentialsApiSupported() && mode === exports.Mode.sameDevice) {
+            console.log("Digital Credentials API support found, proceeding with request using API in same device flow");
+            return await requestCredentialsDigitalCredentialsApi(Object.assign(Object.assign({}, options), {
+                initialiseOptions: initialiseOptions,
+                challenge: challenge
+            }));
+        } else if (initialiseOptions.enableDigitalCredentialsApiSameDeviceFlow) {
+            console.log("Digital Credentials API support not found, falling back to OpenID4VP");
+        }
         if (mode === exports.Mode.sameDevice && "redirectUri" in options) {
             return await requestCredentialsSameDevice(Object.assign(Object.assign({}, options), {
                 initialiseOptions: initialiseOptions,
@@ -1757,7 +1898,8 @@
     };
     const utils = {
         generateChallenge: generateChallenge,
-        unwrap: unwrap
+        unwrap: unwrap,
+        isDigitalCredentialsApiSupported: isDigitalCredentialsApiSupported
     };
     exports.handleRedirectCallback = handleRedirectCallback;
     exports.initialise = initialise;