Feat/jwt vc jsonld

apps/api-gateway/src/app.module.ts

@@ -24,7 +24,9 @@ import { IssuanceModule } from './issuance/issuance.module';
 import { LoggerModule } from '@credebl/logger/logger.module';
 import { NotificationModule } from './notification/notification.module';
 import { Oid4vcIssuanceModule } from './oid4vc-issuance/oid4vc-issuance.module';
+import { Oid4vcHolderModule } from './oid4vc-holder/oid4vc-holder.module';
 import { Oid4vpModule } from './oid4vc-verification/oid4vc-verification.module';
+
 import { OrganizationModule } from './organization/organization.module';
 import { ConfigModule as PlatformConfig } from '@credebl/config/config.module';
 import { PlatformModule } from './platform/platform.module';
@@ -77,6 +79,7 @@ import { shouldLoadOidcModules } from '@credebl/common/common.utils';
     GeoLocationModule,
     CloudWalletModule,
     ConditionalModule.registerWhen(Oid4vcIssuanceModule, shouldLoadOidcModules),
+    ConditionalModule.registerWhen(Oid4vcHolderModule, shouldLoadOidcModules),
     ConditionalModule.registerWhen(Oid4vpModule, shouldLoadOidcModules),
     ConditionalModule.registerWhen(X509Module, shouldLoadOidcModules),
     KeycloakConfigModule

apps/api-gateway/src/oid4vc-holder/dtos/oid4vc-holder.dto.ts

@@ -0,0 +1,40 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsArray, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class OidcResolveCredentialOfferDto {
+  @ApiProperty({ example: 'openid-credential-offer://?credential_offer_uri=...' })
+  @IsString()
+  @IsNotEmpty()
+  credentialOfferUri: string;
+}
+
+export class OidcRequestCredentialDto {
+  @ApiProperty({ example: 'openid-credential-offer://?credential_offer_uri=...' })
+  @IsString()
+  @IsNotEmpty()
+  credentialOfferUri: string;
+
+  @ApiProperty({ example: ['UniversityDegree'] })
+  @IsArray()
+  @IsNotEmpty()
+  credentialsToRequest: string[];
+
+  @ApiPropertyOptional({ example: '1234' })
+  @IsString()
+  @IsOptional()
+  txCode?: string;
+}
+
+export class OidcResolveProofRequestDto {
+  @ApiProperty({ example: 'openid-vc-request://?request_uri=...' })
+  @IsString()
+  @IsNotEmpty()
+  proofRequestUri: string;
+}
+
+export class OidcAcceptProofRequestDto {
+  @ApiProperty({ example: 'openid-vc-request://?request_uri=...' })
+  @IsString()
+  @IsNotEmpty()
+  proofRequestUri: string;
+}

apps/api-gateway/src/oid4vc-holder/oid4vc-holder.controller.ts

@@ -0,0 +1,128 @@
+import { Controller, Post, Body, UseGuards, HttpStatus, Res, Param, UseFilters, Logger } from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBearerAuth,
+  ApiForbiddenResponse,
+  ApiUnauthorizedResponse
+} from '@nestjs/swagger';
+import { AuthGuard } from '@nestjs/passport';
+import { ApiResponseDto } from '../dtos/apiResponse.dto';
+import { UnauthorizedErrorDto } from '../dtos/unauthorized-error.dto';
+import { ForbiddenErrorDto } from '../dtos/forbidden-error.dto';
+import { Response } from 'express';
+import { IResponse } from '@credebl/common/interfaces/response.interface';
+import { Roles } from '../authz/decorators/roles.decorator';
+import { OrgRoles } from 'libs/org-roles/enums';
+import { OrgRolesGuard } from '../authz/guards/org-roles.guard';
+import { CustomExceptionFilter } from 'apps/api-gateway/common/exception-handler';
+import { Oid4vcHolderService } from './oid4vc-holder.service';
+import {
+  OidcAcceptProofRequestDto,
+  OidcRequestCredentialDto,
+  OidcResolveCredentialOfferDto,
+  OidcResolveProofRequestDto
+} from './dtos/oid4vc-holder.dto';
+
+@Controller('orgs/:orgId/oid4vc/holder')
+@UseFilters(CustomExceptionFilter)
+@ApiTags('OID4VC-Holder')
+@ApiUnauthorizedResponse({ description: 'Unauthorized', type: UnauthorizedErrorDto })
+@ApiForbiddenResponse({ description: 'Forbidden', type: ForbiddenErrorDto })
+export class Oid4vcHolderController {
+  private readonly logger = new Logger('Oid4vcHolderController');
+  constructor(private readonly oid4vcHolderService: Oid4vcHolderService) {}
+
+  @Post('resolve-credential-offer')
+  @ApiOperation({
+    summary: 'Resolve OID4VC Credential Offer',
+    description: 'Resolves an OID4VC credential offer for the specified organization.'
+  })
+  @ApiResponse({ status: HttpStatus.OK, description: 'Credential offer resolved successfully.', type: ApiResponseDto })
+  @ApiBearerAuth()
+  @Roles(OrgRoles.OWNER)
+  @UseGuards(AuthGuard('jwt'), OrgRolesGuard)
+  async oidcHolderResolveCredentialOffer(
+    @Param('orgId') orgId: string,
+    @Body() resolveDto: OidcResolveCredentialOfferDto,
+    @Res() res: Response
+  ): Promise<Response> {
+    const data = await this.oid4vcHolderService.oidcHolderResolveCredentialOffer(orgId, resolveDto);
+    const finalResponse: IResponse = {
+      statusCode: HttpStatus.OK,
+      message: 'Credential offer resolved successfully.',
+      data
+    };
+    return res.status(HttpStatus.OK).json(finalResponse);
+  }
+
+  @Post('request-credential')
+  @ApiOperation({
+    summary: 'Request OID4VC Credential',
+    description: 'Requests and stores an OID4VC credential for the specified organization.'
+  })
+  @ApiResponse({ status: HttpStatus.OK, description: 'Credential requested successfully.', type: ApiResponseDto })
+  @ApiBearerAuth()
+  @Roles(OrgRoles.OWNER)
+  @UseGuards(AuthGuard('jwt'), OrgRolesGuard)
+  async oidcHolderRequestCredential(
+    @Param('orgId') orgId: string,
+    @Body() requestDto: OidcRequestCredentialDto,
+    @Res() res: Response
+  ): Promise<Response> {
+    const data = await this.oid4vcHolderService.oidcHolderRequestCredential(orgId, requestDto);
+    const finalResponse: IResponse = {
+      statusCode: HttpStatus.OK,
+      message: 'Credential requested successfully.',
+      data
+    };
+    return res.status(HttpStatus.OK).json(finalResponse);
+  }
+
+  @Post('resolve-proof-request')
+  @ApiOperation({
+    summary: 'Resolve OID4VC Proof Request',
+    description: 'Resolves an OID4VC proof request for the specified organization.'
+  })
+  @ApiResponse({ status: HttpStatus.OK, description: 'Proof request resolved successfully.', type: ApiResponseDto })
+  @ApiBearerAuth()
+  @Roles(OrgRoles.OWNER)
+  @UseGuards(AuthGuard('jwt'), OrgRolesGuard)
+  async oidcHolderResolveProofRequest(
+    @Param('orgId') orgId: string,
+    @Body() resolveDto: OidcResolveProofRequestDto,
+    @Res() res: Response
+  ): Promise<Response> {
+    const data = await this.oid4vcHolderService.oidcHolderResolveProofRequest(orgId, resolveDto);
+    const finalResponse: IResponse = {
+      statusCode: HttpStatus.OK,
+      message: 'Proof request resolved successfully.',
+      data
+    };
+    return res.status(HttpStatus.OK).json(finalResponse);
+  }
+
+  @Post('accept-proof-request')
+  @ApiOperation({
+    summary: 'Accept OID4VC Proof Request',
+    description: 'Accepts an OID4VC proof request for the specified organization.'
+  })
+  @ApiResponse({ status: HttpStatus.OK, description: 'Proof request accepted successfully.', type: ApiResponseDto })
+  @ApiBearerAuth()
+  @Roles(OrgRoles.OWNER)
+  @UseGuards(AuthGuard('jwt'), OrgRolesGuard)
+  async oidcHolderAcceptProofRequest(
+    @Param('orgId') orgId: string,
+    @Body() acceptDto: OidcAcceptProofRequestDto,
+    @Res() res: Response
+  ): Promise<Response> {
+    const data = await this.oid4vcHolderService.oidcHolderAcceptProofRequest(orgId, acceptDto);
+    const finalResponse: IResponse = {
+      statusCode: HttpStatus.OK,
+      message: 'Proof request accepted successfully.',
+      data
+    };
+    return res.status(HttpStatus.OK).json(finalResponse);
+  }
+}

apps/api-gateway/src/oid4vc-holder/oid4vc-holder.module.ts

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { NATSClient } from '@credebl/common/NATSClient';
+import { getNatsOptions } from '@credebl/common/nats.config';
+import { CommonConstants } from '@credebl/common/common.constant';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+import { HttpModule } from '@nestjs/axios';
+import { Oid4vcHolderController } from './oid4vc-holder.controller';
+import { Oid4vcHolderService } from './oid4vc-holder.service';
+
+@Module({
+  imports: [
+    HttpModule,
+    ClientsModule.register([
+      {
+        name: 'NATS_CLIENT',
+        transport: Transport.NATS,
+        options: getNatsOptions(
+          CommonConstants.OIDC4VC_HOLDER_SERVICE,
+          process.env.API_GATEWAY_NKEY_SEED,
+          process.env.NATS_CREDS_FILE
+        )
+      }
+    ])
+  ],
+  controllers: [Oid4vcHolderController],
+  providers: [Oid4vcHolderService, NATSClient]
+})
+export class Oid4vcHolderModule {}

apps/api-gateway/src/oid4vc-holder/oid4vc-holder.service.ts

@@ -0,0 +1,40 @@
+import { NATSClient } from '@credebl/common/NATSClient';
+import { Inject, Injectable } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
+import { BaseService } from 'libs/service/base.service';
+import {
+  OidcAcceptProofRequestDto,
+  OidcRequestCredentialDto,
+  OidcResolveCredentialOfferDto,
+  OidcResolveProofRequestDto
+} from './dtos/oid4vc-holder.dto';
+
+@Injectable()
+export class Oid4vcHolderService extends BaseService {
+  constructor(
+    @Inject('NATS_CLIENT') private readonly holderProxy: ClientProxy,
+    private readonly natsClient: NATSClient
+  ) {
+    super('Oid4vcHolderService');
+  }
+
+  async oidcHolderResolveCredentialOffer(orgId: string, holderPayload: OidcResolveCredentialOfferDto): Promise<object> {
+    const payload = { orgId, holderPayload };
+    return this.natsClient.sendNatsMessage(this.holderProxy, 'oid4vc-holder-resolve-credential-offer', payload);
+  }
+
+  async oidcHolderRequestCredential(orgId: string, holderPayload: OidcRequestCredentialDto): Promise<object> {
+    const payload = { orgId, holderPayload };
+    return this.natsClient.sendNatsMessage(this.holderProxy, 'oid4vc-holder-request-credential', payload);
+  }
+
+  async oidcHolderResolveProofRequest(orgId: string, holderPayload: OidcResolveProofRequestDto): Promise<object> {
+    const payload = { orgId, holderPayload };
+    return this.natsClient.sendNatsMessage(this.holderProxy, 'oid4vc-holder-resolve-proof-request', payload);
+  }
+
+  async oidcHolderAcceptProofRequest(orgId: string, holderPayload: OidcAcceptProofRequestDto): Promise<object> {
+    const payload = { orgId, holderPayload };
+    return this.natsClient.sendNatsMessage(this.holderProxy, 'oid4vc-holder-accept-proof-request', payload);
+  }
+}

apps/api-gateway/src/oid4vc-issuance/dtos/issuer-sessions.dto.ts

@@ -274,11 +274,13 @@ export class CredentialDto {
 
   @ApiProperty({
     description: 'Credential format type',
-    enum: ['mso_mdoc', 'vc+sd-jwt'],
+    enum: ['mso_mdoc', 'vc+sd-jwt', 'jwt_vc_json-ld'],
     example: 'mso_mdoc'
   })
   @IsString()
-  @IsIn(['mso_mdoc', 'vc+sd-jwt'], { message: 'format must be either "mso_mdoc" or "vc+sd-jwt"' })
+  @IsIn(['mso_mdoc', 'vc+sd-jwt', 'jwt_vc_json-ld'], {
+    message: 'format must be either "mso_mdoc", "vc+sd-jwt" or "jwt_vc_json-ld"'
+  })
   format: string;
 
   @ApiProperty({

apps/api-gateway/src/oid4vc-issuance/dtos/oid4vc-issuer-template.dto.ts

@@ -196,6 +196,14 @@ export class SdJwtTemplateDto {
   @IsString()
   vct: string;
 
+  @ApiPropertyOptional({
+    example: ['https://www.w3.org/2018/credentials/v1', 'https://json-ld.org/contexts/person.jsonld'],
+    description: 'JSON-LD context for the credential (optional, defaults to person schema for JSON-LD format)'
+  })
+  @IsArray()
+  @IsOptional()
+  context?: string[];
+
   @ApiProperty({
     type: 'array',
     items: { $ref: getSchemaPath(CredentialAttributeDto) },
@@ -229,8 +237,11 @@ export class CreateCredentialTemplateDto {
   @IsEnum(CredentialFormat)
   format: CredentialFormat;
 
-  @ValidateIf((o: CreateCredentialTemplateDto) => CredentialFormat.SdJwtVc === o.format)
-  @IsEmpty({ message: 'doctype must not be provided when format is "dc+sd-jwt"' })
+  @ValidateIf(
+    (o: CreateCredentialTemplateDto) =>
+      CredentialFormat.SdJwtVc === o.format || CredentialFormat.JwtVcJsonLd === o.format
+  )
+  @IsEmpty({ message: 'doctype must not be provided when format is "dc+sd-jwt" or "jwt_vc_json-ld"' })
   readonly _doctypeAbsentGuard?: unknown;
 
   @ValidateIf((o: CreateCredentialTemplateDto) => CredentialFormat.Mdoc === o.format)
@@ -246,7 +257,7 @@ export class CreateCredentialTemplateDto {
   @Type(({ object }) => {
     if (object.format === CredentialFormat.Mdoc) {
       return MdocTemplateDto;
-    } else if (object.format === CredentialFormat.SdJwtVc) {
+    } else if (object.format === CredentialFormat.SdJwtVc || object.format === CredentialFormat.JwtVcJsonLd) {
       return SdJwtTemplateDto;
     }
   })

apps/api-gateway/src/oid4vc-issuance/oid4vc-issuance.module.ts

@@ -15,7 +15,7 @@ import { HttpModule } from '@nestjs/axios';
         name: 'NATS_CLIENT',
         transport: Transport.NATS,
         options: getNatsOptions(
-          CommonConstants.ISSUANCE_SERVICE,
+          CommonConstants.OIDC4VC_ISSUANCE_SERVICE,
           process.env.API_GATEWAY_NKEY_SEED,
           process.env.NATS_CREDS_FILE
         )

apps/api-gateway/src/oid4vc-verification/dtos/oid4vc-verifier-presentation.dto.ts

@@ -289,7 +289,7 @@ export class DcqlDto {
 @ValidatorConstraint({ name: 'OnlyOneOf', async: false })
 export class OnlyOneOfConstraint implements ValidatorConstraintInterface {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  validate(_: any, args: ValidationArguments): Promise<boolean> | boolean {
+  validate(_: unknown, args: ValidationArguments): Promise<boolean> | boolean {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const object = args.object as Record<string, any>;
     const properties = args.constraints as string[];
@@ -356,10 +356,18 @@ export class PresentationRequestDto {
   @IsDefined()
   @IsEnum(ResponseMode)
   responseMode: ResponseMode;
-  //TODO: check e2e flow and add ResponseMode based restrictions
   @IsOptional()
   expectedOrigins: string[];
 
+  @ApiPropertyOptional({
+    description: 'OpenID4VP version to use',
+    enum: ['v1', 'v1.draft21', 'v1.draft24'],
+    example: 'v1.draft24'
+  })
+  @IsOptional()
+  @IsEnum(['v1', 'v1.draft21', 'v1.draft24'])
+  version?: 'v1' | 'v1.draft21' | 'v1.draft24';
+
   /**
    * Dummy property used to run a class-level validation ensuring mutual exclusivity.
    * This property is not serialized into requests/responses but is required so `class-validator`

apps/oid4vc-holder/src/interfaces/oid4vc-holder.interface.ts

@@ -0,0 +1,17 @@
+export interface IOidcHolderResolveCredentialOffer {
+  credentialOfferUri: string;
+}
+
+export interface IOidcHolderRequestCredential {
+  credentialOfferUri: string;
+  credentialsToRequest: string[];
+  txCode?: string;
+}
+
+export interface IOidcHolderResolveProofRequest {
+  proofRequestUri: string;
+}
+
+export interface IOidcHolderAcceptProofRequest {
+  proofRequestUri: string;
+}

apps/oid4vc-holder/src/main.ts

@@ -0,0 +1,27 @@
+import { NestFactory } from '@nestjs/core';
+import { HttpExceptionFilter } from 'libs/http-exception.filter';
+import { Logger } from '@nestjs/common';
+import { MicroserviceOptions, Transport } from '@nestjs/microservices';
+import { getNatsOptions } from '@credebl/common/nats.config';
+import { CommonConstants } from '@credebl/common/common.constant';
+import NestjsLoggerServiceAdapter from '@credebl/logger/nestjsLoggerServiceAdapter';
+import { Oid4vcHolderModule } from './oid4vc-holder.module';
+
+const logger = new Logger();
+
+async function bootstrap(): Promise<void> {
+  const app = await NestFactory.createMicroservice<MicroserviceOptions>(Oid4vcHolderModule, {
+    transport: Transport.NATS,
+    options: getNatsOptions(
+      CommonConstants.OIDC4VC_HOLDER_SERVICE,
+      process.env.OIDC4VC_HOLDER_NKEY_SEED,
+      process.env.NATS_CREDS_FILE
+    )
+  });
+  app.useLogger(app.get(NestjsLoggerServiceAdapter));
+  app.useGlobalFilters(new HttpExceptionFilter());
+
+  await app.listen();
+  logger.log('OID4VC-Holder-Service Microservice is listening to NATS ');
+}
+bootstrap();