@cef-ebsi/cli 1.3.2 → 1.4.0

package/dist/commands/{conformance-v3.js → conformance.js}

@@ -1,59 +1,10 @@
-import { randomUUID, randomBytes, createHash } from "node:crypto";
-import { URLSearchParams } from "node:url";
 import Joi from "joi";
-import qs from "qs";
 import { base64url } from "multiformats/bases/base64";
-import { compute, getUserPin } from "./compute.js";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { URLSearchParams } from "node:url";
+import qs from "qs";
 import { httpCall, red } from "../utils/index.js";
-function stringify(obj, fields) {
-    if (typeof obj !== "object")
-        throw new Error("not an object");
-    const newObj = {};
-    fields.forEach((f) => {
-        if (obj[f])
-            newObj[f] = obj[f];
-    });
-    return JSON.stringify(newObj);
-}
-export async function conformanceGet(inputs, context) {
-    const apiUrl = context.config.api.conformance.url;
-    const urlPath = inputs.join("");
-    const url = urlPath.startsWith("http") ? urlPath : `${apiUrl}${urlPath}`;
-    const response = await httpCall.get(url, context.httpOpts);
-    return response.data;
-}
-export async function clientMockInitiate(context) {
-    const apiUrl = context.config.api.conformance.url;
-    const { accreditationUrl, proxyId, issuerState } = context.rtVars.user;
-    const response = await httpCall.post(`${apiUrl}/client-mock/initiate`, {
-        did: context.client.did,
-        keys: Object.keys(context.client.keys).map((keyName) => {
-            const key = context.client.keys[keyName];
-            return {
-                ...key.privateKeyJwk,
-                kid: key.kid,
-            };
-        }),
-        ...(accreditationUrl && { attributeUrl: accreditationUrl }),
-        ...(proxyId && { proxyId }),
-        ...(issuerState && { issuerState }),
-    });
-    context.client.clientId = `${apiUrl}/client-mock/${context.client.did}`;
-    context.rtVars.user.clientId =
-        context.client.clientId;
-    return response.data;
-}
-export async function clientMockUpdateList(inputs, context) {
-    const [statusIndex, statusListIndex, value] = inputs;
-    const apiUrl = context.config.api.conformance.url;
-    const response = await httpCall.post(`${apiUrl}/client-mock/updateList`, {
-        did: context.client.did,
-        id: statusIndex.toString(),
-        position: Number(statusListIndex),
-        value: Number(value),
-    });
-    return response.data;
-}
+import { compute, getUserPin } from "./compute.js";
 export async function authMockAuthorize(inputs, context) {
     const [openIdCredentialIssuer, openIdConfiguration, requestedTypes, inputAlg, codeVerifier, issuerState,] = inputs;
     const alg = inputAlg || "ES256";
@@ -74,26 +25,26 @@ export async function authMockAuthorize(inputs, context) {
             authorization_endpoint: "openid:",
         }
         : {
-            redirect_uris: [`${context.client.clientId}/code-cb`],
-            jwks_uri: `${context.client.clientId}/jwks`,
             authorization_endpoint: `${context.client.clientId}/authorize`,
+            jwks_uri: `${context.client.clientId}/jwks`,
+            redirect_uris: [`${context.client.clientId}/code-cb`],
         };
     const authorizationDetails = [
         {
-            type: "openid_credential",
             format: "jwt_vc",
             locations: [openIdCredentialIssuer.credential_issuer],
+            type: "openid_credential",
             types: requestedTypes,
         },
     ];
     const queryParams = {
-        scope: "openid",
         client_id: clientId,
         client_metadata: JSON.stringify(clientMetadata),
         redirect_uri: isPKCEChallenge
             ? "openid://callback"
             : `${context.client.clientId}/code-cb`,
         response_type: "code",
+        scope: "openid",
         state: randomUUID(),
         ...(isPKCEChallenge && {
             code_challenge: codeChallenge,
@@ -104,10 +55,10 @@ export async function authMockAuthorize(inputs, context) {
     };
     const jwtPayload = {
         ...queryParams,
-        client_metadata: clientMetadata,
+        aud: authorizationServer,
         authorization_details: authorizationDetails,
+        client_metadata: clientMetadata,
         iss: clientId,
-        aud: authorizationServer,
     };
     const requestParam = await context.client.signJWT(jwtPayload, {}, alg);
     const responseAuthorize = await httpCall.get(`${openIdConfiguration.authorization_endpoint}?${new URLSearchParams({
@@ -118,7 +69,7 @@ export async function authMockAuthorize(inputs, context) {
     const locationUrl = new URL(location);
     if (locationUrl.searchParams.get("error"))
         throw new Error(locationUrl.searchParams.toString());
-    const responseQueryParams = qs.parse(locationUrl.search.substring(1));
+    const responseQueryParams = qs.parse(locationUrl.search.slice(1));
     return responseQueryParams;
 }
 export async function authMockDirectPostIdToken(inputs, context) {
@@ -127,16 +78,16 @@ export async function authMockDirectPostIdToken(inputs, context) {
     Joi.assert(alg, Joi.string().valid("ES256K", "ES256", "EdDSA", "RS256"));
     const authorizationServer = openIdCredentialIssuer.authorization_server ??
         openIdCredentialIssuer.credential_issuer;
-    const { state, nonce } = issuerRequest;
+    const { nonce, state } = issuerRequest;
     const iat = Math.floor(Date.now() / 1000);
     const exp = iat + 5 * 60;
     const idTokenDirectPost = await context.client.signJWT({
-        nonce,
-        iss: context.client.did,
-        sub: context.client.did,
         aud: authorizationServer,
-        iat,
         exp,
+        iat,
+        iss: context.client.did,
+        nonce,
+        sub: context.client.did,
     }, {}, alg);
     const responseDirectPost = await httpCall.post(issuerRequest.redirect_uri, new URLSearchParams({
         id_token: idTokenDirectPost,
@@ -150,7 +101,7 @@ export async function authMockDirectPostIdToken(inputs, context) {
     const locationUrl = new URL(location);
     if (locationUrl.searchParams.get("error"))
         throw new Error(locationUrl.searchParams.toString());
-    const responseQueryParams = qs.parse(locationUrl.search.substring(1));
+    const responseQueryParams = qs.parse(locationUrl.search.slice(1));
     return responseQueryParams;
 }
 export async function authMockDirectPostVpToken(inputs) {
@@ -158,111 +109,111 @@ export async function authMockDirectPostVpToken(inputs) {
     const { state } = issuerRequest;
     const presentationSubmission = type === "holder"
         ? {
-            id: randomUUID(),
             definition_id: "holder-wallet-qualification-presentation",
             descriptor_map: [
                 {
+                    format: "jwt_vp",
                     id: "same-device-authorised-in-time-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "same-device-authorised-in-time-credential",
                         format: "jwt_vc",
+                        id: "same-device-authorised-in-time-credential",
                         path: "$.vp.verifiableCredential[0]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "cross-device-authorised-in-time-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "cross-device-authorised-in-time-credential",
                         format: "jwt_vc",
+                        id: "cross-device-authorised-in-time-credential",
                         path: "$.vp.verifiableCredential[1]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "same-device-authorised-deferred-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "same-device-authorised-deferred-credential",
                         format: "jwt_vc",
+                        id: "same-device-authorised-deferred-credential",
                         path: "$.vp.verifiableCredential[2]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "cross-device-authorised-deferred-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "cross-device-authorised-deferred-credential",
                         format: "jwt_vc",
+                        id: "cross-device-authorised-deferred-credential",
                         path: "$.vp.verifiableCredential[3]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "same-device-pre-authorised-in-time-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "same-device-pre-authorised-in-time-credential",
                         format: "jwt_vc",
+                        id: "same-device-pre-authorised-in-time-credential",
                         path: "$.vp.verifiableCredential[4]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "cross-device-pre-authorised-in-time-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "cross-device-pre-authorised-in-time-credential",
                         format: "jwt_vc",
+                        id: "cross-device-pre-authorised-in-time-credential",
                         path: "$.vp.verifiableCredential[5]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "same-device-pre-authorised-deferred-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "same-device-pre-authorised-deferred-credential",
                         format: "jwt_vc",
+                        id: "same-device-pre-authorised-deferred-credential",
                         path: "$.vp.verifiableCredential[6]",
                     },
                 },
                 {
+                    format: "jwt_vp",
                     id: "cross-device-pre-authorised-deferred-credential",
                     path: "$",
-                    format: "jwt_vp",
                     path_nested: {
-                        id: "cross-device-pre-authorised-deferred-credential",
                         format: "jwt_vc",
+                        id: "cross-device-pre-authorised-deferred-credential",
                         path: "$.vp.verifiableCredential[7]",
                     },
                 },
             ],
+            id: randomUUID(),
         }
         : {
-            id: randomUUID(),
             definition_id: "va-to-onboard-presentation",
             descriptor_map: [
                 {
-                    id: "verifiable-authorisation-to-onboard",
                     format: "jwt_vp",
+                    id: "verifiable-authorisation-to-onboard",
                     path: "$",
                     path_nested: {
-                        id: "verifiable-authorisation-to-onboard",
                         format: "jwt_vc",
+                        id: "verifiable-authorisation-to-onboard",
                         path: "$.vp.verifiableCredential[0]",
                     },
                 },
             ],
+            id: randomUUID(),
         };
     const responseDirectPost = await httpCall.post(issuerRequest.redirect_uri, new URLSearchParams({
-        vp_token: vpJwt,
-        state,
         presentation_submission: JSON.stringify(presentationSubmission),
+        state,
+        vp_token: vpJwt,
     }).toString(), {
         headers: {
             "Content-Type": "application/x-www-form-urlencoded",
@@ -272,7 +223,7 @@ export async function authMockDirectPostVpToken(inputs) {
     const locationUrl = new URL(location);
     if (locationUrl.searchParams.get("error"))
         throw new Error(locationUrl.searchParams.toString());
-    const responseQueryParams = qs.parse(locationUrl.search.substring(1));
+    const responseQueryParams = qs.parse(locationUrl.search.slice(1));
     return responseQueryParams;
 }
 export async function authMockToken(inputs, context) {
@@ -281,21 +232,18 @@ export async function authMockToken(inputs, context) {
     const isPKCEChallenge = !!codeVerifier;
     const authorizationServer = openIdCredentialIssuer.authorization_server ??
         openIdCredentialIssuer.credential_issuer;
-    let queryParams;
-    if (type === "preAuthorised") {
-        queryParams = {
+    const queryParams = type === "preAuthorised"
+        ? {
             grant_type: "urn:ietf:params:oauth:grant-type:pre-authorized_code",
             "pre-authorized_code": code,
             user_pin: getUserPin(context.client.did),
-        };
-    }
-    else {
-        queryParams = {
-            grant_type: "authorization_code",
+        }
+        : {
             code,
+            grant_type: "authorization_code",
             ...(!isPKCEChallenge && {
-                client_id: context.client.clientId,
                 client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+                client_id: context.client.clientId,
                 redirect_uri: `${context.client.clientId}/code-cb`,
             }),
             ...(isPKCEChallenge && {
@@ -304,16 +252,15 @@ export async function authMockToken(inputs, context) {
                 redirect_uri: "openid://callback",
             }),
         };
-    }
     const iat = Math.floor(Date.now() / 1000);
     const exp = iat + 5 * 60;
     const jwtPayload = {
         ...queryParams,
-        iss: context.client.clientId,
         aud: authorizationServer,
-        sub: context.client.clientId,
-        iat,
         exp,
+        iat,
+        iss: context.client.clientId,
+        sub: context.client.clientId,
     };
     const clientAssertion = await context.client.signJWT(jwtPayload, {}, alg);
     const responseToken = await httpCall.post(openIdConfiguration.token_endpoint, new URLSearchParams({
@@ -326,65 +273,115 @@ export async function authMockToken(inputs, context) {
     });
     return responseToken.data;
 }
-export async function issuerMockCredential(inputs, context) {
-    const [openIdCredentialIssuer, nonce, requestedTypes, inputAlg] = inputs;
-    const alg = inputAlg || "ES256";
-    const clientId = context.client.didVersion === 1
-        ? context.client.clientId
-        : context.client.did;
-    const iat = Math.floor(Date.now() / 1000);
-    const exp = iat + 5 * 60;
-    const jwtPayload = {
-        nonce,
-        iss: clientId,
-        aud: openIdCredentialIssuer.credential_issuer,
-        iat,
-        exp,
-    };
-    const proofJwt = await context.client.signJWT(jwtPayload, {
-        typ: "openid4vci-proof+jwt",
-    }, alg);
-    const responseCredential = await httpCall.post(`${openIdCredentialIssuer.credential_issuer}/credential`, {
-        types: requestedTypes,
-        format: "jwt_vc",
-        proof: {
-            proof_type: "jwt",
-            jwt: proofJwt,
+export async function check(inputs, context) {
+    const [intent, preAuthorizedCode, userPin] = inputs;
+    const apiUrl = context.config.api.conformance.url;
+    const response = await httpCall.post(`${apiUrl}/check`, {
+        data: {
+            clientId: context.client.clientId,
+            credentialIssuer: context.client.clientId,
+            credentialIssuerDid: context.client.did,
+            did: context.client.did,
+            issuerState: context.client.issuerState,
+            ...(preAuthorizedCode && {
+                preAuthorizedCode,
+                userPin,
+            }),
         },
-    }, context.httpOpts);
-    return responseCredential.data;
+        intent,
+    });
+    if (!response.data.success) {
+        red(response.data.errors);
+        throw new Error(`check ${intent} failed: ${response.data.errors
+            ? JSON.stringify(response.data.errors)
+            : "unknown error"}`);
+    }
+    return response.data;
 }
-export async function issuerMockDeferred(inputs) {
-    const [openIdCredentialIssuer, acceptanceToken] = inputs;
-    const response = await httpCall.post(openIdCredentialIssuer.deferred_credential_endpoint, undefined, {
-        headers: {
-            authorization: `Bearer ${acceptanceToken}`,
-        },
+export async function clientMockInitiate(context) {
+    const apiUrl = context.config.api.conformance.url;
+    const { accreditationUrl, issuerState, proxyId } = context.rtVars.user;
+    const response = await httpCall.post(`${apiUrl}/client-mock/initiate`, {
+        did: context.client.did,
+        keys: Object.keys(context.client.keys).map((keyName) => {
+            const key = context.client.keys[keyName];
+            return {
+                ...key.privateKeyJwk,
+                kid: key.kid,
+            };
+        }),
+        ...(accreditationUrl && { attributeUrl: accreditationUrl }),
+        ...(proxyId && { proxyId }),
+        ...(issuerState && { issuerState }),
     });
+    context.client.clientId = `${apiUrl}/client-mock/${context.client.did}`;
+    context.rtVars.user.clientId =
+        context.client.clientId;
     return response.data;
 }
-export async function issuerMockInitiateCredentialOffer(inputs, context) {
-    const [initiateCredentialOfferEndpoint, credentialType] = inputs;
-    const requestParams = {
-        credential_type: credentialType,
-        credential_offer_endpoint: "openid-credential-offer://",
-        client_id: context.client.did,
-    };
-    let response = await httpCall.get(`${initiateCredentialOfferEndpoint}?${qs.stringify(requestParams)}`);
-    let search;
-    if (credentialType.startsWith("CTWalletSame")) {
-        search = new URL(response.headers.location)
-            .search;
-    }
-    else {
-        search = new URL(response.data).search;
-    }
-    const parsedCredentialOffer = qs.parse(search.slice(1));
-    if (parsedCredentialOffer.credential_offer_uri) {
-        response = await httpCall.get(parsedCredentialOffer.credential_offer_uri);
-        return response.data;
+export async function clientMockUpdateList(inputs, context) {
+    const [statusIndex, statusListIndex, value] = inputs;
+    const apiUrl = context.config.api.conformance.url;
+    const response = await httpCall.post(`${apiUrl}/client-mock/updateList`, {
+        did: context.client.did,
+        id: statusIndex.toString(),
+        position: Number(statusListIndex),
+        value: Number(value),
+    });
+    return response.data;
+}
+export async function conformance(method, inputs, context) {
+    switch (method) {
+        case "authMockAuthorize": {
+            return authMockAuthorize(inputs, context);
+        }
+        case "authMockDirectPostIdToken": {
+            return authMockDirectPostIdToken(inputs, context);
+        }
+        case "authMockDirectPostVpToken": {
+            return authMockDirectPostVpToken(inputs);
+        }
+        case "authMockToken": {
+            return authMockToken(inputs, context);
+        }
+        case "check": {
+            return check(inputs, context);
+        }
+        case "clientMockInitiate": {
+            return clientMockInitiate(context);
+        }
+        case "clientMockUpdateList": {
+            return clientMockUpdateList(inputs, context);
+        }
+        case "get": {
+            return conformanceGet(inputs, context);
+        }
+        case "getCredential": {
+            return getCredential(inputs, context);
+        }
+        case "holder": {
+            return holder(inputs, context);
+        }
+        case "issuerMockCredential": {
+            return issuerMockCredential(inputs, context);
+        }
+        case "issuerMockDeferred": {
+            return issuerMockDeferred(inputs);
+        }
+        case "issuerMockInitiateCredentialOffer": {
+            return issuerMockInitiateCredentialOffer(inputs, context);
+        }
+        default: {
+            throw new Error(`Invalid method '${method}'`);
+        }
     }
-    return qs.parse(parsedCredentialOffer.credential_offer);
+}
+export async function conformanceGet(inputs, context) {
+    const apiUrl = context.config.api.conformance.url;
+    const urlPath = inputs.join("");
+    const url = urlPath.startsWith("http") ? urlPath : `${apiUrl}${urlPath}`;
+    const response = await httpCall.get(url, context.httpOpts);
+    return response.data;
 }
 export async function getCredential(inputs, context) {
     const [type, inputAlg, inputVc, inputIssuer] = inputs;
@@ -393,12 +390,9 @@ export async function getCredential(inputs, context) {
     const vcString = typeof vc === "string" ? vc : JSON.stringify(vc);
     let openIdCredentialIssuerUrl;
     if (inputIssuer) {
-        if (inputIssuer.startsWith("http")) {
-            openIdCredentialIssuerUrl = `${inputIssuer}/.well-known/openid-credential-issuer`;
-        }
-        else {
-            openIdCredentialIssuerUrl = `/client-mock/${inputIssuer}/.well-known/openid-credential-issuer`;
-        }
+        openIdCredentialIssuerUrl = inputIssuer.startsWith("http")
+            ? `${inputIssuer}/.well-known/openid-credential-issuer`
+            : `/client-mock/${inputIssuer}/.well-known/openid-credential-issuer`;
     }
     else {
         openIdCredentialIssuerUrl =
@@ -406,29 +400,27 @@ export async function getCredential(inputs, context) {
     }
     let requestedTypes;
     switch (type) {
-        case "onboard": {
+        case "ctrevocable": {
             requestedTypes = [
                 "VerifiableCredential",
                 "VerifiableAttestation",
-                "VerifiableAuthorisationToOnboard",
+                "CTRevocable",
             ];
             break;
         }
-        case "ti": {
+        case "onboard": {
             requestedTypes = [
                 "VerifiableCredential",
                 "VerifiableAttestation",
-                "VerifiableAccreditation",
-                "VerifiableAccreditationToAttest",
+                "VerifiableAuthorisationToOnboard",
             ];
             break;
         }
-        case "tao": {
+        case "qualification": {
             requestedTypes = [
                 "VerifiableCredential",
                 "VerifiableAttestation",
-                "VerifiableAccreditation",
-                "VerifiableAccreditationToAccredit",
+                "CTAAQualificationCredential",
             ];
             break;
         }
@@ -440,24 +432,27 @@ export async function getCredential(inputs, context) {
             ];
             break;
         }
-        case "ctrevocable": {
+        case "tao": {
             requestedTypes = [
                 "VerifiableCredential",
                 "VerifiableAttestation",
-                "CTRevocable",
+                "VerifiableAccreditation",
+                "VerifiableAccreditationToAccredit",
             ];
             break;
         }
-        case "qualification": {
+        case "ti": {
             requestedTypes = [
                 "VerifiableCredential",
                 "VerifiableAttestation",
-                "CTAAQualificationCredential",
+                "VerifiableAccreditation",
+                "VerifiableAccreditationToAttest",
             ];
             break;
         }
-        default:
+        default: {
             throw new Error(`type ${type} is not supported`);
+        }
     }
     // conformance clientMockInitiate
     console.log("==> conformance clientMockInitiate");
@@ -539,15 +534,13 @@ export async function getCredential(inputs, context) {
     console.log(`==> compute decodeJWT ${credential}`);
     const decodedCredential = (await compute("decodeJWT", [credential], context));
     let reservedAttributeId = "";
-    if (decodedCredential.payload.vc &&
-        decodedCredential.payload.vc.credentialSubject &&
-        decodedCredential.payload.vc.credentialSubject.reservedAttributeId) {
+    if (decodedCredential.payload.vc?.credentialSubject?.reservedAttributeId) {
         reservedAttributeId =
             decodedCredential.payload.vc.credentialSubject.reservedAttributeId;
     }
     return {
-        vc: credential,
         reservedAttributeId,
+        vc: credential,
     };
 }
 export async function holder(inputs, context) {
@@ -594,12 +587,12 @@ export async function holder(inputs, context) {
     const isPreauthorised = communicationType
         .toLowerCase()
         .startsWith("preauthorised");
-    if (!useCredentialOffer) {
-        if (isPreauthorised)
-            throw new Error("For preauthorised credentials set use-credential-offer");
+    if (useCredentialOffer) {
+        credentialOffer = await issuerMockInitiateCredentialOffer([initiateCredentialOfferEndpoint, credentialType], context);
     }
     else {
-        credentialOffer = await issuerMockInitiateCredentialOffer([initiateCredentialOfferEndpoint, credentialType], context);
+        if (isPreauthorised)
+            throw new Error("For preauthorised credentials set use-credential-offer");
     }
     // opIssuer: conformance get /issuer-mock/.well-known/openid-credential-issuer
     console.log(`==> conformance get ${openIdCredentialIssuerUrl}`);
@@ -698,75 +691,70 @@ export async function holder(inputs, context) {
     }
     return credential;
 }
-export async function check(inputs, context) {
-    const [intent, preAuthorizedCode, userPin] = inputs;
-    const apiUrl = context.config.api.conformance.url;
-    const response = await httpCall.post(`${apiUrl}/check`, {
-        data: {
-            clientId: context.client.clientId,
-            did: context.client.did,
-            credentialIssuer: context.client.clientId,
-            credentialIssuerDid: context.client.did,
-            issuerState: context.client.issuerState,
-            ...(preAuthorizedCode && {
-                preAuthorizedCode,
-                userPin,
-            }),
+export async function issuerMockCredential(inputs, context) {
+    const [openIdCredentialIssuer, nonce, requestedTypes, inputAlg] = inputs;
+    const alg = inputAlg || "ES256";
+    const clientId = context.client.didVersion === 1
+        ? context.client.clientId
+        : context.client.did;
+    const iat = Math.floor(Date.now() / 1000);
+    const exp = iat + 5 * 60;
+    const jwtPayload = {
+        aud: openIdCredentialIssuer.credential_issuer,
+        exp,
+        iat,
+        iss: clientId,
+        nonce,
+    };
+    const proofJwt = await context.client.signJWT(jwtPayload, {
+        typ: "openid4vci-proof+jwt",
+    }, alg);
+    const responseCredential = await httpCall.post(`${openIdCredentialIssuer.credential_issuer}/credential`, {
+        format: "jwt_vc",
+        proof: {
+            jwt: proofJwt,
+            proof_type: "jwt",
+        },
+        types: requestedTypes,
+    }, context.httpOpts);
+    return responseCredential.data;
+}
+export async function issuerMockDeferred(inputs) {
+    const [openIdCredentialIssuer, acceptanceToken] = inputs;
+    const response = await httpCall.post(openIdCredentialIssuer.deferred_credential_endpoint, undefined, {
+        headers: {
+            authorization: `Bearer ${acceptanceToken}`,
         },
-        intent,
     });
-    if (!response.data.success) {
-        red(response.data.errors);
-        throw new Error(`check ${intent} failed: ${response.data.errors
-            ? JSON.stringify(response.data.errors)
-            : "unknown error"}`);
-    }
     return response.data;
 }
-export async function conformanceV3(method, inputs, context) {
-    switch (method) {
-        case "get": {
-            return conformanceGet(inputs, context);
-        }
-        case "clientMockInitiate": {
-            return clientMockInitiate(context);
-        }
-        case "clientMockUpdateList": {
-            return clientMockUpdateList(inputs, context);
-        }
-        case "authMockAuthorize": {
-            return authMockAuthorize(inputs, context);
-        }
-        case "authMockDirectPostIdToken": {
-            return authMockDirectPostIdToken(inputs, context);
-        }
-        case "authMockDirectPostVpToken": {
-            return authMockDirectPostVpToken(inputs);
-        }
-        case "authMockToken": {
-            return authMockToken(inputs, context);
-        }
-        case "issuerMockCredential": {
-            return issuerMockCredential(inputs, context);
-        }
-        case "issuerMockDeferred": {
-            return issuerMockDeferred(inputs);
-        }
-        case "issuerMockInitiateCredentialOffer": {
-            return issuerMockInitiateCredentialOffer(inputs, context);
-        }
-        case "getCredential": {
-            return getCredential(inputs, context);
-        }
-        case "holder": {
-            return holder(inputs, context);
-        }
-        case "check": {
-            return check(inputs, context);
-        }
-        default:
-            throw new Error(`Invalid method '${method}'`);
+export async function issuerMockInitiateCredentialOffer(inputs, context) {
+    const [initiateCredentialOfferEndpoint, credentialType] = inputs;
+    const requestParams = {
+        client_id: context.client.did,
+        credential_offer_endpoint: "openid-credential-offer://",
+        credential_type: credentialType,
+    };
+    let response = await httpCall.get(`${initiateCredentialOfferEndpoint}?${qs.stringify(requestParams)}`);
+    const search = credentialType.startsWith("CTWalletSame")
+        ? new URL(response.headers.location).search
+        : new URL(response.data).search;
+    const parsedCredentialOffer = qs.parse(search.slice(1));
+    if (parsedCredentialOffer.credential_offer_uri) {
+        response = await httpCall.get(parsedCredentialOffer.credential_offer_uri);
+        return response.data;
     }
+    return qs.parse(parsedCredentialOffer.credential_offer);
+}
+function stringify(obj, fields) {
+    if (typeof obj !== "object")
+        throw new Error("not an object");
+    const newObj = {};
+    for (const f of fields) {
+        if (obj[f])
+            newObj[f] = obj[f];
+    }
+    return JSON.stringify(newObj);
 }
-export default conformanceV3;
-//# sourceMappingURL=conformance-v3.js.map
+export default conformance;
+//# sourceMappingURL=conformance.js.map