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

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: 2024-10-20
- * Version: 1.0.1
+ * Generated: 2024-10-21
+ * Version: 2.0.0-preview-digital-credential-api.1
  * Dependencies:
  */
 
@@ -200,6 +200,11 @@ const CreateSessionResponseValidator = v__namespace.object({
     sessionUrl: v__namespace.string()
 });
 
+const CreateDigitalCredentialsApiSessionResponseValidator = v__namespace.object({
+    sessionId: v__namespace.string(),
+    request: v__namespace.object({})
+});
+
 var LocalStorageKey;
 
 (function(LocalStorageKey) {
@@ -262,7 +267,9 @@ exports.RequestCredentialsErrorType = void 0;
 })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
 
 const InitialiseOptionsValidator = v__namespace.object({
-    apiBaseUrl: v__namespace.string()
+    apiBaseUrl: v__namespace.string(),
+    enableDigitalCredentialsApiSameDeviceFlow: v__namespace.optional(v__namespace.boolean()),
+    enableDigitalCredentialsApiCrossDeviceFlow: v__namespace.optional(v__namespace.boolean())
 });
 
 let initialiseOptions = undefined;
@@ -378,6 +385,64 @@ const isMobileDetect = userAgent => isMobile.isMobile({
     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 neverthrow.err(responseResult.error);
+    }
+    const data = await responseResult.value.json();
+    if (!isType(CreateDigitalCredentialsApiSessionResponseValidator)(data)) {
+        return neverthrow.err({
+            type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
+            message: "Create digital credentials api session return unsupported response"
+        });
+    }
+    return neverthrow.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 neverthrow.err(responseResult.error);
+    }
+    const data = await responseResult.value.json();
+    return neverthrow.ok(data);
+};
+
 exports.CrossDeviceCallbackErrorType = void 0;
 
 (function(CrossDeviceCallbackErrorType) {
@@ -519,12 +584,12 @@ const requestCredentialsCrossDevice = async options => {
     });
 };
 
-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;
@@ -534,7 +599,7 @@ const requestCredentialsSameDevice = async options => {
     if (!storedChallenge) {
         return neverthrow.err({
             type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
+            message: SameDeviceRequestCredentialsErrorMessage$1.FailedToStoreChallenge
         });
     }
     const createSessionResult = await createSession({
@@ -547,7 +612,7 @@ const requestCredentialsSameDevice = async options => {
     if (createSessionResult.isErr()) {
         return neverthrow.err({
             type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: SameDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+            message: SameDeviceRequestCredentialsErrorMessage$1.FailedToCreateSession,
             cause: createSessionResult.error
         });
     }
@@ -559,6 +624,71 @@ const requestCredentialsSameDevice = async options => {
     });
 };
 
+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 neverthrow.err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
+        });
+    }
+    const createSessionResult = await createDigitalCredentialsApiSession({
+        credentialQuery: credentialQuery,
+        challenge: storedChallenge,
+        apiBaseUrl: apiBaseUrl
+    });
+    if (createSessionResult.isErr()) {
+        return neverthrow.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 neverthrow.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 neverthrow.ok({
+            sessionId: sessionId,
+            result: result.value
+        });
+    }
+    return neverthrow.err({
+        type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+        message: "Invalid response from digital credentials api"
+    });
+};
+
 const requestCredentials = async options => {
     var _a;
     const initialiseOptions = getInitialiseOptions();
@@ -568,6 +698,24 @@ const requestCredentials = async options => {
     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,
@@ -650,7 +798,8 @@ const handleRedirectCallback = async () => {
 
 const utils = {
     generateChallenge: generateChallenge,
-    unwrap: unwrap
+    unwrap: unwrap,
+    isDigitalCredentialsApiSupported: isDigitalCredentialsApiSupported
 };
 
 exports.handleRedirectCallback = handleRedirectCallback;