@bedrock/vc-delivery 7.9.0 → 7.10.0

package/lib/index.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2022-2025 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2022-2026 Digital Bazaar, Inc. All rights reserved.
  */
 import * as bedrock from '@bedrock/core';
 import * as workflowSchemas from '../schemas/bedrock-vc-workflow.js';
@@ -33,9 +33,10 @@ async function _initService({serviceType, routePrefix}) {
   const createConfigBody = structuredClone(schemas.createConfigBody);
   const updateConfigBody = structuredClone(schemas.updateConfigBody);
   const schemasToUpdate = [createConfigBody, updateConfigBody];
-  const {
-    credentialTemplates, steps, initialStep, issuerInstances
-  } = workflowSchemas;
+  const credentialTemplates = workflowSchemas.credentialTemplates();
+  const steps = workflowSchemas.steps();
+  const initialStep = workflowSchemas.initialStep();
+  const issuerInstances = workflowSchemas.issuerInstances();
   for(const schema of schemasToUpdate) {
     // add config requirements to workflow configs
     schema.properties.credentialTemplates = credentialTemplates;

package/lib/inviteRequest/http.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2025 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2025-2026 Digital Bazaar, Inc. All rights reserved.
  */
 import * as inviteRequest from './inviteRequest.js';
 import {asyncHandler} from '@bedrock/express';

package/lib/issue.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2022-2024 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2022-2026 Digital Bazaar, Inc. All rights reserved.
  */
 import * as bedrock from '@bedrock/core';
 import {
@@ -15,92 +15,103 @@ const {util: {BedrockError}} = bedrock;
 export async function issue({
   workflow, exchange, step, format = 'application/vc'
 } = {}) {
-  // use any templates from workflow and variables from exchange to produce
-  // credentials to be issued; issue via the configured issuer instance
-  const {credentialTemplates = []} = workflow;
-  if(!credentialTemplates || credentialTemplates.length === 0) {
-    // nothing to issue
+  // eval all issue requests for current step in exchange
+  const issueRequests = await _evalIssueRequests({workflow, exchange, step});
+
+  // return early if there is no explicit VP in step nor nothing to issue
+  if(!step?.verifiablePresentation && issueRequests.length === 0) {
     return {response: {}};
   }
 
-  // generate all issue requests for current step in exchange
-  const issueRequests = await _createIssueRequests({
-    workflow, exchange, step, credentialTemplates
-  });
-  // issue all VCs
-  const vcs = await _issue({workflow, issueRequests, format});
+  // run all issue requests
+  const issuedVcs = await _issue({workflow, issueRequests, format});
 
-  // generate VP to return VCs
-  const verifiablePresentation = createPresentation();
-  // FIXME: add any encrypted VCs to VP
+  // generate VP to return VCs; use any explicitly defined VP from the step
+  // (which may include out-of-band issued VCs that are to be delivered)
+  const verifiablePresentation =
+    structuredClone(step?.verifiablePresentation) ?? createPresentation();
 
-  // add any issued VCs to VP
-  if(vcs.length > 0) {
+  // add issued VCs to VP
+  if(issuedVcs.length > 0) {
+    let vcs = verifiablePresentation.verifiableCredential;
+    if(!vcs) {
+      vcs = issuedVcs;
+    } else if(Array.isArray(vcs)) {
+      vcs = [...vcs, ...issuedVcs];
+    } else {
+      vcs = [vcs, ...issuedVcs];
+    }
     verifiablePresentation.verifiableCredential = vcs;
   }
   return {response: {verifiablePresentation}, format};
 }
 
-async function _createIssueRequests({
-  workflow, exchange, step, credentialTemplates
-}) {
-  // if step does not define `issueRequests`, then use all for templates for
-  // backwards compatibility
-  let params;
-  if(!step?.issueRequests) {
-    params = credentialTemplates.map(typedTemplate => ({typedTemplate}));
-  } else {
-    // resolve all issue requests params in parallel
-    const variables = getTemplateVariables({workflow, exchange});
-    params = await Promise.all(step.issueRequests.map(async r => {
-      // find the typed template to use
-      let typedTemplate;
-      if(r.credentialTemplateIndex !== undefined) {
-        typedTemplate = credentialTemplates[r.credentialTemplateIndex];
-      } else if(r.credentialTemplateId !== undefined) {
-        typedTemplate = credentialTemplates.find(
-          t => t.id === r.credentialTemplateId);
-      }
-      if(typedTemplate === undefined) {
+async function _evalIssueRequests({workflow, exchange, step}) {
+  // evaluate all issue requests in parallel
+  const requests = await _getIssueRequests({workflow, exchange, step});
+  return Promise.all(requests.map(({typedTemplate, variables}) =>
+    evaluateTemplate({workflow, exchange, typedTemplate, variables})));
+}
+
+async function _getIssueRequests({workflow, exchange, step}) {
+  // use any templates from workflow and variables from exchange to produce
+  // credentials to be issued; issue via the configured issuer instance
+  const {credentialTemplates = []} = workflow;
+  if(!(credentialTemplates.length > 0)) {
+    // no issue requests
+    return [];
+  }
+
+  if(!step ||
+    (!step.issueRequests && Object.keys(workflow.steps).length === 1)) {
+    // backwards-compatibility: deprecated workflows with no step or a single
+    // step do not explicitly define `issueRequests` but instead use all
+    // templates for issue requests
+    return credentialTemplates.map(typedTemplate => ({typedTemplate}));
+  }
+
+  // resolve all issue request params in parallel
+  const variables = getTemplateVariables({workflow, exchange});
+  return Promise.all(step.issueRequests.map(async r => {
+    // find the typed template to use
+    let typedTemplate;
+    if(r.credentialTemplateIndex !== undefined) {
+      typedTemplate = credentialTemplates[r.credentialTemplateIndex];
+    } else if(r.credentialTemplateId !== undefined) {
+      typedTemplate = credentialTemplates.find(
+        t => t.id === r.credentialTemplateId);
+    }
+    if(typedTemplate === undefined) {
+      throw new BedrockError(
+        'Credential template ' +
+        `"${r.credentialTemplateIndex ?? r.credentialTemplateId}" not found.`, {
+          name: 'DataError',
+          details: {httpStatusCode: 500, public: true}
+        });
+    }
+
+    // allow different variables to be specified for the typed template
+    let vars = variables;
+    if(r.variables !== undefined) {
+      vars = typeof r.variables === 'string' ?
+        variables[r.variables] : r.variables;
+      if(!(vars && typeof vars === 'object')) {
         throw new BedrockError(
-          'Credential template ' +
-          `"${r.credentialTemplateIndex ?? r.credentialTemplateId}" ` +
-          'not found.', {
+          `Issue request variables "${r.variables}" not found or invalid.`, {
             name: 'DataError',
             details: {httpStatusCode: 500, public: true}
           });
       }
-
-      // allow different variables to be specified for the typed template
-      let vars = variables;
-      if(r.variables !== undefined) {
-        if(typeof r.variables === 'string') {
-          vars = variables[r.variables];
-        } else {
-          vars = r.variables;
-        }
-        if(!(vars && typeof vars === 'object')) {
-          throw new BedrockError(
-            `Issue request variables "${r.variables}" not found or invalid.`, {
-              name: 'DataError',
-              details: {httpStatusCode: 500, public: true}
-            });
-        }
+    }
+    return {
+      typedTemplate,
+      variables: {
+        // always include globals but allow local override
+        globals: variables.globals,
+        ...vars
       }
-      return {
-        typedTemplate,
-        variables: {
-          // always include globals but allow local override
-          globals: variables.globals,
-          ...vars
-        }
-      };
-    }));
-  }
-
-  // evaluate all issue requests
-  return Promise.all(params.map(({typedTemplate, variables}) =>
-    evaluateTemplate({workflow, exchange, typedTemplate, variables})));
+    };
+  }));
 }
 
 function _getIssueZcap({workflow, zcaps, format}) {

package/lib/oid4/authorizationResponse.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2022-2025 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2022-2026 Digital Bazaar, Inc. All rights reserved.
  */
 import * as bedrock from '@bedrock/core';
 import {
@@ -23,7 +23,7 @@ bedrock.events.on('bedrock.init', () => {
   // create validators for x-www-form-urlencoded parsed data
   VALIDATORS.presentation = compile({schema: verifiablePresentationSchema()});
   VALIDATORS.presentationSubmission = compile({
-    schema: presentationSubmissionSchema
+    schema: presentationSubmissionSchema()
   });
 });
 

package/lib/oid4/http.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2022-2025 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2022-2026 Digital Bazaar, Inc. All rights reserved.
  */
 import * as oid4vci from './oid4vci.js';
 import * as oid4vp from './oid4vp.js';
@@ -158,7 +158,7 @@ export async function createRoutes({
     routes.token,
     cors(),
     urlencodedSmall,
-    validate({bodySchema: openIdTokenBody}),
+    validate({bodySchema: openIdTokenBody()}),
     getConfigMiddleware,
     getExchange,
     asyncHandler(async (req, res) => {
@@ -177,7 +177,7 @@ export async function createRoutes({
   app.post(
     routes.credential,
     cors(),
-    validate({bodySchema: openIdCredentialBody}),
+    validate({bodySchema: openIdCredentialBody()}),
     getConfigMiddleware,
     getExchange,
     asyncHandler(async (req, res) => {
@@ -273,7 +273,7 @@ export async function createRoutes({
   app.post(
     routes.batchCredential,
     cors(),
-    validate({bodySchema: openIdBatchCredentialBody}),
+    validate({bodySchema: openIdBatchCredentialBody()}),
     getConfigMiddleware,
     getExchange,
     asyncHandler(async (req, res) => {

package/lib/vcapi.js

@@ -264,7 +264,7 @@ export async function processExchange({req, res, workflow, exchangeRecord}) {
 
         // FIXME: remove this once the other FIXME below is implemented
         // and provides support for issuance in non-last step
-        if(step.issueRequests?.length > 0) {
+        if(step.verifiablePresentation || step.issueRequests?.length > 0) {
           throw new BedrockError(
             'Invalid step detected; continuing exchanges currently must ' +
             'only issue in the final step.', {
@@ -291,14 +291,8 @@ export async function processExchange({req, res, workflow, exchangeRecord}) {
         }
 
         // FIXME: there may be VCs to issue during this step, do so before
-        // sending the VPR above
-      } else if(step.nextStep) {
-        // next steps without VPRs are prohibited
-        throw new BedrockError(
-          'Invalid step detected; continuing exchanges must include VPRs.', {
-            name: 'DataError',
-            details: {httpStatusCode: 500, public: true}
-          });
+        // sending the VPR above and remove error that prevents continuing
+        // exchanges that issue
       }
       currentStep = step.nextStep;
     }
@@ -432,6 +426,6 @@ async function _createProtocols({workflow, exchange, step}) {
 
 function _supportsVcApi({workflow, step}) {
   return step?.verifiablePresentationRequest ||
-    step?.issueRequests?.length > 0 ||
+    step?.verifiablePresentation ||
     workflow?.credentialTemplates?.length > 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrock/vc-delivery",
-  "version": "7.9.0",
+  "version": "7.10.0",
   "type": "module",
   "description": "Bedrock Verifiable Credential Delivery",
   "main": "./lib/index.js",

package/schemas/bedrock-vc-workflow.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2022-2025 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2022-2026 Digital Bazaar, Inc. All rights reserved.
  */
 import {MAX_ISSUER_INSTANCES} from '../lib/constants.js';
 import {schemas} from '@bedrock/validation';
@@ -150,6 +150,21 @@ const jwkKeyPair = {
   }
 };
 
+function verifiableOrEnvelopedCredentials() {
+  return {
+    anyOf: [
+      verifiableCredential(),
+      envelopedVerifiableCredential, {
+        type: 'array',
+        minItems: 1,
+        items: {
+          anyOf: [verifiableCredential(), envelopedVerifiableCredential]
+        }
+      }
+    ]
+  };
+}
+
 export function verifiablePresentation() {
   return {
     title: 'Verifiable Presentation',
@@ -173,18 +188,7 @@ export function verifiablePresentation() {
           type: 'string'
         }
       },
-      verifiableCredential: {
-        anyOf: [
-          verifiableCredential(),
-          envelopedVerifiableCredential, {
-            type: 'array',
-            minItems: 1,
-            items: {
-              anyOf: [verifiableCredential(), envelopedVerifiableCredential]
-            }
-          }
-        ]
-      },
+      verifiableCredential: verifiableOrEnvelopedCredentials(),
       holder: idOrObjectWithId(),
       proof: schemas.proof()
     }
@@ -319,12 +323,14 @@ const typedTemplate = {
   }
 };
 
-export const credentialTemplates = {
-  title: 'Credential Templates',
-  type: 'array',
-  minItems: 1,
-  items: typedTemplate
-};
+export function credentialTemplates() {
+  return {
+    title: 'Credential Templates',
+    type: 'array',
+    minItems: 1,
+    items: typedTemplate
+  };
+}
 
 // to be updated in specific locations with `properties` and `required`
 const zcapReferenceIds = {
@@ -364,13 +370,15 @@ const issuerInstance = {
   }
 };
 
-export const issuerInstances = {
-  title: 'Issuer Instances',
-  type: 'array',
-  minItems: 1,
-  maxItems: MAX_ISSUER_INSTANCES,
-  items: issuerInstance
-};
+export function issuerInstances() {
+  return {
+    title: 'Issuer Instances',
+    type: 'array',
+    minItems: 1,
+    maxItems: MAX_ISSUER_INSTANCES,
+    items: issuerInstance
+  };
+}
 
 const issueRequestParameters = {
   title: 'Issue Request Parameters',
@@ -493,168 +501,188 @@ const oid4vpClientProfile = {
   }
 };
 
-export const oid4vpClientProfiles = {
-  title: 'OID4VP Client Profiles',
-  type: 'object',
-  additionalProperties: false,
-  patternProperties: {
-    '^.*$': oid4vpClientProfile
-  }
-};
-
-const step = {
-  title: 'Exchange Step',
-  type: 'object',
-  minProperties: 1,
-  additionalProperties: false,
-  // step can either use a template so it will be generated using variables
-  // associated with the exchange, or static values can be provided
-  oneOf: [{
-    // `stepTemplate` must be present and nothing else
-    required: ['stepTemplate'],
-    not: {
-      required: [
-        'allowUnprotectedPresentation',
-        'callback',
-        'createChallenge',
-        'issueRequests',
-        'jwtDidProofRequest',
-        'nextStep',
-        'openId',
-        'presentationSchema',
-        'verifiablePresentationRequest'
-      ]
-    }
-  }, {
-    // anything except `stepTemplate` can be used
-    not: {
-      required: ['stepTemplate']
+export function oid4vpClientProfiles() {
+  return {
+    title: 'OID4VP Client Profiles',
+    type: 'object',
+    additionalProperties: false,
+    patternProperties: {
+      '^.*$': oid4vpClientProfile
     }
-  }],
-  properties: {
-    allowUnprotectedPresentation: {
-      type: 'boolean'
-    },
-    callback: {
-      type: 'object',
-      required: ['url'],
-      additionalProperties: false,
-      properties: {
-        url: {
-          type: 'string'
-        }
+  };
+}
+
+function step() {
+  return {
+    title: 'Exchange Step',
+    type: 'object',
+    minProperties: 1,
+    additionalProperties: false,
+    // step can either use a template so it will be generated using variables
+    // associated with the exchange, or static values can be provided
+    oneOf: [{
+      // `stepTemplate` must be present and nothing else
+      required: ['stepTemplate'],
+      not: {
+        required: [
+          'allowUnprotectedPresentation',
+          'callback',
+          'createChallenge',
+          'issueRequests',
+          'jwtDidProofRequest',
+          'nextStep',
+          'openId',
+          'presentationSchema',
+          'verifiablePresentation',
+          'verifiablePresentationRequest'
+        ]
       }
-    },
-    createChallenge: {
-      type: 'boolean'
-    },
-    issueRequests: {
-      type: 'array',
-      minItems: 0,
-      items: issueRequestParameters
-    },
-    jwtDidProofRequest: {
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        acceptedMethods: {
-          title: 'Accepted DID Methods',
-          type: 'array',
-          minItems: 1,
-          items: {
-            title: 'Accepted DID Method',
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-              method: {
-                type: 'string'
-              }
-            }
-          }
-        },
-        allowedAlgorithms: {
-          title: 'Allowed JWT Algorithms',
-          type: 'array',
-          minItems: 1,
-          items: {
+    }, {
+      // anything except `stepTemplate` can be used
+      not: {
+        required: ['stepTemplate']
+      }
+    }],
+    properties: {
+      allowUnprotectedPresentation: {
+        type: 'boolean'
+      },
+      callback: {
+        type: 'object',
+        required: ['url'],
+        additionalProperties: false,
+        properties: {
+          url: {
             type: 'string'
           }
         }
-      }
-    },
-    nextStep: {
-      type: 'string'
-    },
-    // required to support OID4VP (but can be provided by step template instead)
-    openId: {
-      // either a single top-level client profile is specified here or
-      // `clientProfiles` is specified with nested client profiles
-      oneOf: [{
-        oid4vpClientProfile
-      }, {
+      },
+      createChallenge: {
+        type: 'boolean'
+      },
+      // issue request parameters for VCs that are to be issued and delivered
+      // during this step
+      issueRequests: {
+        type: 'array',
+        minItems: 0,
+        items: issueRequestParameters
+      },
+      jwtDidProofRequest: {
         type: 'object',
-        required: ['clientProfiles'],
         additionalProperties: false,
         properties: {
-          clientProfiles: oid4vpClientProfiles
-        }
-      }]
-    },
-    presentationSchema: {
-      type: 'object',
-      required: ['type', 'jsonSchema'],
-      additionalProperties: false,
-      properties: {
-        type: {
-          type: 'string'
-        },
-        jsonSchema: {
-          type: 'object'
+          acceptedMethods: {
+            title: 'Accepted DID Methods',
+            type: 'array',
+            minItems: 1,
+            items: {
+              title: 'Accepted DID Method',
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                method: {
+                  type: 'string'
+                }
+              }
+            }
+          },
+          allowedAlgorithms: {
+            title: 'Allowed JWT Algorithms',
+            type: 'array',
+            minItems: 1,
+            items: {
+              type: 'string'
+            }
+          }
         }
-      }
-    },
-    stepTemplate: typedTemplate,
-    verifiablePresentationRequest: {
-      type: 'object'
-    },
-    verifyPresentationOptions: {
-      type: 'object',
-      properties: {
-        checks: {
-          type: 'object'
+      },
+      nextStep: {
+        type: 'string'
+      },
+      // required to support OID4VP
+      // (but can be provided by step template instead)
+      openId: {
+        // either a single top-level client profile is specified here or
+        // `clientProfiles` is specified with nested client profiles
+        oneOf: [{
+          oid4vpClientProfile
+        }, {
+          type: 'object',
+          required: ['clientProfiles'],
+          additionalProperties: false,
+          properties: {
+            clientProfiles: oid4vpClientProfiles()
+          }
+        }]
+      },
+      presentationSchema: {
+        type: 'object',
+        required: ['type', 'jsonSchema'],
+        additionalProperties: false,
+        properties: {
+          type: {
+            type: 'string'
+          },
+          jsonSchema: {
+            type: 'object'
+          }
         }
       },
-      additionalProperties: true
-    },
-    verifyPresentationResultSchema: {
-      type: 'object',
-      required: ['type', 'jsonSchema'],
-      additionalProperties: false,
-      properties: {
-        type: {
-          type: 'string'
+      stepTemplate: typedTemplate,
+      // the base verifiable presentation to use in this step; any VCs that
+      // are issued in this step (see: `issueRequests`) will be added to this
+      // VP, in which case any proofs on it will be invalidated; VCs that were
+      // previously issued but are to be delivered during this step can be
+      // present in `verifiablePresentation.verifiableCredential` and any newly
+      // issued ones will be appended to that field; if not present and any
+      // VCs are to be issued, this will be auto-generated
+      verifiablePresentation: verifiablePresentation(),
+      verifiablePresentationRequest: {
+        type: 'object'
+      },
+      verifyPresentationOptions: {
+        type: 'object',
+        properties: {
+          checks: {
+            type: 'object'
+          }
         },
-        jsonSchema: {
-          type: 'object'
+        additionalProperties: true
+      },
+      verifyPresentationResultSchema: {
+        type: 'object',
+        required: ['type', 'jsonSchema'],
+        additionalProperties: false,
+        properties: {
+          type: {
+            type: 'string'
+          },
+          jsonSchema: {
+            type: 'object'
+          }
         }
       }
     }
-  }
-};
+  };
+}
 
-export const steps = {
-  title: 'Exchange Steps',
-  type: 'object',
-  additionalProperties: false,
-  patternProperties: {
-    '^.*$': step
-  }
-};
+export function steps() {
+  return {
+    title: 'Exchange Steps',
+    type: 'object',
+    additionalProperties: false,
+    patternProperties: {
+      '^.*$': step()
+    }
+  };
+}
 
-export const initialStep = {
-  title: 'Initial Exchange Step',
-  type: 'string'
-};
+export function initialStep() {
+  return {
+    title: 'Initial Exchange Step',
+    type: 'string'
+  };
+}
 
 export function useExchangeBody() {
   return {
@@ -672,83 +700,89 @@ export function useExchangeBody() {
   };
 }
 
-const openIdCredentialRequest = {
-  title: 'OpenID Credential Request',
-  type: 'object',
-  additionalProperties: false,
-  required: ['credential_definition', 'format'],
-  properties: {
-    credential_definition: credentialDefinition,
-    format: {
-      type: 'string',
-      enum: ['di_vc', 'ldp_vc', 'jwt_vc_json-ld', 'jwt_vc_json']
-    },
-    did: {
-      type: 'string'
-    },
-    proof: {
-      title: 'DID Authn Proof JWT',
-      type: 'object',
-      additionalProperties: false,
-      required: ['proof_type', 'jwt'],
-      properties: {
-        proof_type: {
-          type: 'string',
-          enum: ['jwt']
-        },
-        jwt: {
-          type: 'string'
+function openIdCredentialRequest() {
+  return {
+    title: 'OpenID Credential Request',
+    type: 'object',
+    additionalProperties: false,
+    required: ['credential_definition', 'format'],
+    properties: {
+      credential_definition: credentialDefinition,
+      format: {
+        type: 'string',
+        enum: ['di_vc', 'ldp_vc', 'jwt_vc_json-ld', 'jwt_vc_json']
+      },
+      did: {
+        type: 'string'
+      },
+      proof: {
+        title: 'DID Authn Proof JWT',
+        type: 'object',
+        additionalProperties: false,
+        required: ['proof_type', 'jwt'],
+        properties: {
+          proof_type: {
+            type: 'string',
+            enum: ['jwt']
+          },
+          jwt: {
+            type: 'string'
+          }
         }
       }
     }
-  }
-};
+  };
+}
 
 export const openIdCredentialBody = openIdCredentialRequest;
 
-export const openIdBatchCredentialBody = {
-  title: 'OpenID Batch Credential Request',
-  type: 'object',
-  additionalProperties: false,
-  required: ['credential_requests'],
-  properties: {
-    credential_requests: {
-      title: 'OpenID Credential Requests',
-      type: 'array',
-      minItems: 1,
-      items: openIdCredentialRequest
+export function openIdBatchCredentialBody() {
+  return {
+    title: 'OpenID Batch Credential Request',
+    type: 'object',
+    additionalProperties: false,
+    required: ['credential_requests'],
+    properties: {
+      credential_requests: {
+        title: 'OpenID Credential Requests',
+        type: 'array',
+        minItems: 1,
+        items: openIdCredentialRequest()
+      }
     }
-  }
-};
+  };
+}
 
-export const openIdTokenBody = {
-  title: 'OpenID Token Request',
-  type: 'object',
-  additionalProperties: false,
-  required: ['grant_type'],
-  properties: {
-    grant_type: {
-      type: 'string'
-    },
-    'pre-authorized_code': {
-      type: 'string'
-    },
-    // FIXME: there is no implementation for using these fields yet:
-    // user_pin: {
-    //   type: 'string'
-    // },
-    // // params for `authorization_code` grant type
-    // code: {
-    //   type: 'string'
-    // },
-    // verifier: {
-    //   type: 'string'
-    // },
-    // redirect_uri: {
-    //   type: 'string'
-    // }
-  }
-};
+export function openIdTokenBody() {
+  return {
+    title: 'OpenID Token Request',
+    type: 'object',
+    additionalProperties: false,
+    required: ['grant_type'],
+    properties: {
+      grant_type: {
+        type: 'string'
+      },
+      'pre-authorized_code': {
+        type: 'string'
+      },
+      // FIXME: there is no implementation for using these fields yet:
+      // user_pin: {
+      //   type: 'string'
+      // },
+      // // params for `authorization_code` grant type
+      // code: {
+      //   type: 'string'
+      // },
+      // verifier: {
+      //   type: 'string'
+      // },
+      // redirect_uri: {
+      //   type: 'string'
+      // }
+    }
+  };
+}
 
 const presentationDescriptor = {
   title: 'Presentation Submission Descriptor',
@@ -771,26 +805,28 @@ const presentationDescriptor = {
   }
 };
 
-export const presentationSubmission = {
-  title: 'Presentation Submission',
-  type: 'object',
-  additionalProperties: false,
-  required: ['id', 'definition_id', 'descriptor_map'],
-  properties: {
-    id: {
-      type: 'string'
-    },
-    definition_id: {
-      type: 'string'
-    },
-    descriptor_map: {
-      title: 'Presentation Submission Descriptor Map',
-      type: 'array',
-      minItems: 0,
-      items: presentationDescriptor
+export function presentationSubmission() {
+  return {
+    title: 'Presentation Submission',
+    type: 'object',
+    additionalProperties: false,
+    required: ['id', 'definition_id', 'descriptor_map'],
+    properties: {
+      id: {
+        type: 'string'
+      },
+      definition_id: {
+        type: 'string'
+      },
+      descriptor_map: {
+        title: 'Presentation Submission Descriptor Map',
+        type: 'array',
+        minItems: 0,
+        items: presentationDescriptor
+      }
     }
-  }
-};
+  };
+}
 
 export function openIdAuthorizationResponseBody() {
   return {