Merge pull request #129 from credebl/endorser-request-and-submit

feat: schema endorsement request and sign transaction

apps/agent-service/src/agent-service.controller.ts

@@ -106,4 +106,14 @@ export class AgentServiceController {
   async getProofFormData(payload: { url: string, apiKey: string }): Promise<object> {
     return this.agentServiceService.getProofFormData(payload.url, payload.apiKey);
   }
+
+  @MessagePattern({ cmd: 'agent-schema-endorsement-request' })
+  async schemaEndorsementRequest(payload: { url: string, apiKey: string, requestSchemaPayload:object }): Promise<object> {
+    return this.agentServiceService.schemaEndorsementRequest(payload.url, payload.apiKey, payload.requestSchemaPayload);
+  }
+
+  @MessagePattern({ cmd: 'agent-sign-transaction' })
+  async signTransaction(payload: { url: string, apiKey: string, signEndorsementPayload:string }): Promise<object> {
+    return this.agentServiceService.signTransaction(payload.url, payload.apiKey, payload.signEndorsementPayload);
+  }
 }

apps/agent-service/src/agent-service.service.ts

@@ -889,5 +889,31 @@ export class AgentServiceService {
     }
   }
 
+  async schemaEndorsementRequest(url: string, apiKey: string, requestSchemaPayload:object): Promise<object> {
+    try {
+      const schemaRequest = await this.commonService
+      .httpPost(url, requestSchemaPayload, { headers: { 'x-api-key': apiKey } })
+      .then(async response => response);
+      return schemaRequest;
+    } catch (error) {
+      this.logger.error(`Error in schema endorsement request in agent service : ${JSON.stringify(error)}`);
+      throw new RpcException(error.response ? error.response : error);
+    }
+  }
+
+  async signTransaction(url: string, apiKey: string, signEndorsementPayload: string): Promise<object> {
+    try {
+
+      const signEndorsementTransaction = await this.commonService
+      .httpPost(url, signEndorsementPayload, { headers: { 'x-api-key': apiKey } })
+      .then(async response => response);
+
+      return signEndorsementTransaction;
+    } catch (error) {
+      this.logger.error(`Error in sign transaction in agent service : ${JSON.stringify(error)}`);
+      throw new RpcException(error.response ? error.response : error);
+    }
+  }
+
 }
 

apps/api-gateway/src/ecosystem/dtos/request-schema-dto.ts

@@ -0,0 +1,47 @@
+import { ApiExtraModels, ApiProperty } from '@nestjs/swagger';
+import { IsArray, IsBoolean, IsInt, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+@ApiExtraModels()
+
+class AttributeValue {
+
+  @IsString()
+  @IsNotEmpty({ message: 'attributeName is required.' })
+  attributeName: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'schemaDataType is required.' })
+  schemaDataType: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'displayName is required.' })
+  displayName: string;
+}
+
+export class RequestSchemaDto {
+  @ApiProperty()
+  @IsString({ message: 'name must be in string format.' })
+  name: string;
+
+  @ApiProperty()
+  @IsInt({ message: 'version must be in number format.' })
+  version: number;
+
+  @ApiProperty({
+    'example': [
+      {
+        attributeName: 'name',
+        schemaDataType: 'string',
+        displayName: 'Name'
+      }
+    ]
+  })
+  @IsArray({ message: 'attributes must be an array' })
+  @IsNotEmpty({ message: 'please provide valid attributes' })
+  attributes: AttributeValue[];
+
+  @ApiProperty()
+  @IsBoolean({ message: 'endorse must be a boolean.' })
+  @IsOptional()
+  endorse?: boolean;
+
+}

apps/api-gateway/src/ecosystem/ecosystem.controller.ts

@@ -4,7 +4,7 @@ import { EcosystemService } from './ecosystem.service';
 import { Post, Get } from '@nestjs/common';
 import { Body } from '@nestjs/common';
 import { Res } from '@nestjs/common';
-import { CreateEcosystemDto } from './dtos/create-ecosystem-dto';
+import { RequestSchemaDto } from './dtos/request-schema-dto';
 import IResponseType from '@credebl/common/interfaces/response.interface';
 import { HttpStatus } from '@nestjs/common';
 import { Response } from 'express';
@@ -27,6 +27,7 @@ import { EcosystemRolesGuard } from '../authz/guards/ecosystem-roles.guard';
 import { EcosystemsRoles, Roles } from '../authz/decorators/roles.decorator';
 import { OrgRolesGuard } from '../authz/guards/org-roles.guard';
 import { OrgRoles } from 'libs/org-roles/enums';
+import { CreateEcosystemDto } from './dtos/create-ecosystem-dto';
 
 
 @UseFilters(CustomExceptionFilter)
@@ -168,6 +169,33 @@ export class EcosystemController {
     return res.status(HttpStatus.CREATED).json(finalResponse);
   }
 
+  @Post('/:orgId/transaction/schema')
+  @ApiOperation({ summary: 'Request new schema', description: 'Request new schema' })
+  @ApiResponse({ status: 201, description: 'Success', type: ApiResponseDto })
+  @UseGuards(AuthGuard('jwt'))
+  @ApiBearerAuth()
+  async requestSchemaTransaction(@Body() requestSchemaPayload: RequestSchemaDto, @Param('orgId') orgId: number, @Res() res: Response): Promise<Response> {
+    await this.ecosystemService.schemaEndorsementRequest(requestSchemaPayload, orgId);
+    const finalResponse: IResponseType = {
+      statusCode: HttpStatus.CREATED,
+      message: ResponseMessages.ecosystem.success.schemaRequest
+    };
+    return res.status(HttpStatus.CREATED).json(finalResponse);
+  }
+
+  @Post('transaction/sign/:endorsementId')
+  @ApiOperation({ summary: 'Sign transaction', description: 'Sign transaction' })
+  @ApiResponse({ status: 201, description: 'Success', type: ApiResponseDto })
+  @UseGuards(AuthGuard('jwt'))
+  @ApiBearerAuth()
+  async SignEndorsementRequests(@Param('endorsementId') endorsementId: string, @Res() res: Response): Promise<Response> {
+    await this.ecosystemService.signTransaction(endorsementId);
+    const finalResponse: IResponseType = {
+      statusCode: HttpStatus.CREATED,
+      message: ResponseMessages.ecosystem.success.sign
+    };
+    return res.status(HttpStatus.CREATED).json(finalResponse);
+  }
 
   /**
    * 

apps/api-gateway/src/ecosystem/ecosystem.service.ts

@@ -6,6 +6,7 @@ import { BulkEcosystemInvitationDto } from './dtos/send-invitation.dto';
 import { AcceptRejectEcosystemInvitationDto } from './dtos/accept-reject-ecosysteminvitation-dto';
 import { GetAllEcosystemInvitationsDto } from './dtos/get-all-sent-invitations.dto';
 import { GetAllSentEcosystemInvitationsDto } from './dtos/get-all-sent-ecosystemInvitations-dto';
+import { RequestSchemaDto } from './dtos/request-schema-dto';
 
 
 @Injectable()
@@ -99,4 +100,14 @@ export class EcosystemService extends BaseService {
     }
 
 
+    async schemaEndorsementRequest(requestSchemaPayload: RequestSchemaDto, orgId: number): Promise<object> {
+      const payload = { requestSchemaPayload, orgId};
+      return this.sendNats(this.serviceProxy, 'schema-endorsement-request', payload);
+    }
+
+
+    async signTransaction(endorsementId:string): Promise<object> {
+      const payload = { endorsementId };
+      return this.sendNats(this.serviceProxy, 'sign-endorsement-transaction', payload);
+    }
 }

apps/ecosystem/enums/ecosystem.enum.ts

@@ -12,4 +12,11 @@ export enum EcosystemInvitationStatus {
     ACCEPTED = 'accepted',
     REJECTED = 'rejected',
     PENDING = 'pending'
+}
+
+export enum endorsementTransactionStatus {
+    REQUESTED = 'Requested',
+    SIGNED = 'Signed',
+    DECLINED = 'Declined',
+    SUBMITED = 'Submited'
 }

apps/ecosystem/interfaces/ecosystem.interfaces.ts

@@ -0,0 +1,51 @@
+export interface RequestSchemaEndorsement {
+  orgId: number
+  name: string;
+  version: number;
+  attributes: IAttributeValue[];
+  endorse?: boolean;
+}
+
+export interface IAttributeValue {
+  attributeName: string;
+  schemaDataType: string;
+  displayName: string
+}
+
+export interface SchemaTransactionPayload {
+  endorserDid: string;
+  endorse: boolean;
+  attributes: string[];
+  version: string;
+  name: string;
+  issuerId: string;
+}
+
+export interface SchemaMessage {
+  message?: {
+    jobId: string;
+    schemaState: {
+      state: string;
+      action: string;
+      schemaId: string;
+      schema: Record<string, unknown>;
+      schemaRequest: string;
+    };
+    registrationMetadata: Record<string, unknown>;
+    schemaMetadata: Record<string, unknown>;
+  };
+}
+
+export interface SchemaTransactionResponse {
+  endorserDid: string;
+  authorDid: string;
+  requestPayload: string;
+  status: string;
+  ecosystemOrgId: string;
+}
+
+export interface SignedTransactionMessage {
+  message?: {
+    signedTransaction: string;
+  };
+}

apps/ecosystem/src/ecosystem.controller.ts

@@ -6,6 +6,7 @@ import { Body } from '@nestjs/common';
 import { BulkSendInvitationDto } from '../dtos/send-invitation.dto';
 import { AcceptRejectEcosystemInvitationDto } from '../dtos/accept-reject-ecosysteminvitation.dto';
 import { FetchInvitationsPayload } from '../interfaces/invitations.interface';
+import { RequestSchemaEndorsement } from '../interfaces/ecosystem.interfaces';
 
 @Controller()
 export class EcosystemController {
@@ -105,4 +106,27 @@ export class EcosystemController {
     );
   }
 
+   /**
+   * 
+   * @param payload 
+   * @returns Schema endorsement request
+   */
+   @MessagePattern({ cmd: 'schema-endorsement-request' })
+   async schemaEndorsementRequest(
+     @Body() payload: { requestSchemaPayload: RequestSchemaEndorsement; orgId: number }
+     ): Promise<object> {
+     return this.ecosystemService.requestSchemaEndorsement(payload.requestSchemaPayload, payload.orgId);
+   }
+
+   /**
+   * 
+   * @param payload 
+   * @returns sign endorsement request
+   */
+   @MessagePattern({ cmd: 'sign-endorsement-transaction' })
+   async signTransaction(
+     @Body() payload: { endorsementId: string }
+     ): Promise<object> {
+     return this.ecosystemService.signTransaction(payload.endorsementId);
+   }
 }