@sovrahq/waci 3.4.0

package/src/handlers/issuance/step-6-issue-credential.handler.ts

@@ -0,0 +1,63 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  AckStatus,
+  Actor,
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageResponseType,
+  WACIMessageType,
+} from '../../types';
+import { createUUID } from '../../utils';
+import { ProblemReportMessage } from '../../types/problem-report';
+
+@RegisterHandler(Actor.Holder, WACIMessageType.IssueCredential)
+export class IssueCredentialHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+
+    const problemReport = new ProblemReportMessage();
+    const fulfillmentAcceptance = await callbacks[
+      Actor.Holder
+    ].handleCredentialFulfillment({
+      message,
+      credentialFulfillment: message.attachments
+    });
+    const holderDID = message.to[0];
+    const issuerDID = message.from;
+
+    //TODO define when this is neccesary
+    if (!fulfillmentAcceptance) {
+      return {
+        responseType: WACIMessageResponseType.ReplyThread,
+        message: {
+          type: WACIMessageType.ProblemReport,
+          id: createUUID(),
+          thid: message.thid,
+          from: holderDID,
+          to: [issuerDID],
+          body: problemReport.presentProofMessage(
+            'Holder did not accept the credential',
+          ),
+        },
+      };
+    }
+
+    return {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.IssuanceAck,
+        id: createUUID(),
+        thid: message.thid,
+        from: holderDID,
+        to: [issuerDID],
+        body: {
+          status: AckStatus.Ok,
+        },
+      },
+    };
+  }
+}

package/src/handlers/issuance/step-7-ack-message.handler.ts

@@ -0,0 +1,21 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageType,
+  Actor,
+} from '../../types';
+
+@RegisterHandler(Actor.Issuer, WACIMessageType.IssuanceAck)
+export class IssuanceAckMessageHandler implements WACIMessageHandler {
+  async handle(messageThread: WACIMessage[], callbacks: any): Promise<void> {
+    const message = messageThread[messageThread.length - 1];
+    await callbacks[Actor.Issuer].handleIssuanceAck({
+      status: message.body.status,
+      message: message,
+      from: message.from,
+      pthid: message.pthid,
+      thid: message.thid,
+    });
+  }
+}

package/src/handlers/presentation/step-3-propose-presentation.handler.ts

@@ -0,0 +1,67 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageType,
+  WACIMessageResponseType,
+  Actor,
+  InputDescriptor,
+  CredentialRequest,
+  PresentationDefinitionFrame,
+} from '../../types';
+import { createUUID } from '../../utils';
+
+@RegisterHandler(Actor.Verifier, WACIMessageType.ProposePresentation)
+export class ProposePresentationHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+    const holderDID = message.from;
+    const verifierDID = message.to[0];
+    const invitationId = message.pthid;
+    const { inputDescriptors, frame } = await callbacks[
+      Actor.Verifier
+    ].getPresentationDefinition({ invitationId });
+
+    const requestPresentationMessage = this.createMessage(inputDescriptors, frame);
+    
+    return {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.RequestPresentation,
+        id: createUUID(),
+        thid: message.id,
+        from: verifierDID,
+        to: [holderDID],
+        body: {},
+        attachments: [requestPresentationMessage],
+      },
+    };
+  }
+
+  private createMessage(
+    inputDescriptors: InputDescriptor[],
+    frame: PresentationDefinitionFrame
+  ): CredentialRequest {
+    return {
+      id: createUUID(),
+      media_type: 'application/json',
+      format: 'dif/presentation-exchange/definitions@v1.0',
+      data: {
+        json: {
+          options: {
+            challenge: createUUID(),
+          },
+          presentation_definition: {
+            id: createUUID(),
+            input_descriptors: inputDescriptors,
+            frame: frame
+          },
+        },
+      },
+    };
+  }
+}

package/src/handlers/presentation/step-4-1-presentation-proceed.handler.ts

@@ -0,0 +1,100 @@
+import {
+  WACIMessage,
+  WACIMessageHandlerResponse,
+  WACIMessageResponseType,
+  WACIMessageType,
+  Actor,
+  PresentationDefinition,
+  CredentialPresentation,
+} from '../../types';
+import { createUUID } from '../../utils';
+
+export class PresentationProceed {
+  static async presentCredentials(
+    messageThread: WACIMessage[],
+    credentialsToPresent: any[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+    const holderDID = message.to[0];
+    const verifierDID = message.from;
+    const presentationDefinition =
+      message.attachments?.[0]?.data?.json?.presentation_definition as PresentationDefinition;
+    const challenge = message.attachments?.[0]?.data?.json?.options?.challenge;
+
+    if (!challenge) throw new Error('No challenge defined');
+    if (!presentationDefinition?.input_descriptors) {
+      throw new Error('Presentation definition without input required');
+    }
+
+    const credentialPresentation = await this.createMessage(
+      presentationDefinition,
+      challenge,
+      credentialsToPresent,
+      holderDID,
+      message,
+      callbacks,
+    );
+    return {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.PresentProof,
+        id: createUUID(),
+        thid: message.thid,
+        from: holderDID,
+        to: [verifierDID],
+        body: {},
+        attachments: [credentialPresentation],
+      },
+    };
+  }
+
+  private static async createMessage(
+    presentationDefinition: PresentationDefinition,
+    challenge: string,
+    credentialsToPresent: any[],
+    holderDID: string,
+    message: WACIMessage,
+    callbacks: any
+  ): Promise<CredentialPresentation> {
+    const definition_id = presentationDefinition.id;
+    const descriptor_map = presentationDefinition.input_descriptors.map(
+      (descriptor, index) => ({
+        id: descriptor.id,
+        format: 'ldp_vp',
+        path: `$.verifiableCredential[${index}]`,
+      }),
+    );
+
+    const messageData = {
+      '@context': [
+        'https://extrimian.blob.core.windows.net/rskec/securityv1.jsonld',
+        'https://extrimian.blob.core.windows.net/rskec/credentialsv1.jsonld',
+        'https://extrimian.blob.core.windows.net/rskec/presentation-exchangesubmissionv1.jsonld',
+      ],
+      type: ['VerifiablePresentation', 'PresentationSubmission'],
+      holder: holderDID,
+      presentation_submission: {
+        id: createUUID(),
+        definition_id,
+        descriptor_map,
+      },
+      verifiableCredential: credentialsToPresent,
+    };
+
+    const signedData = await callbacks[Actor.Holder].signPresentation({
+      contentToSign: messageData,
+      challenge,
+      message
+    });
+
+    return {
+      id: createUUID(),
+      media_type: 'application/ld+json',
+      format: 'dif/presentation-exchange/submission@v1.0',
+      data: {
+        json: signedData,
+      },
+    } as CredentialPresentation;
+  }
+}

package/src/handlers/presentation/step-4-request-presentation.handler.ts

@@ -0,0 +1,115 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageResponseType,
+  WACIMessageType,
+  Actor,
+  PresentationDefinition,
+  CredentialPresentation,
+} from '../../types';
+import { createUUID } from '../../utils';
+import { CredentialPresentationResponse } from '../../callbacks';
+
+@RegisterHandler(Actor.Holder, WACIMessageType.RequestPresentation)
+export class RequestPresentationHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+    const holderDID = message.to[0];
+    const verifierDID = message.from;
+    const presentationDefinition =
+      message.attachments?.[0]?.data?.json?.presentation_definition as PresentationDefinition;
+    const challenge = message.attachments?.[0]?.data?.json?.options?.challenge;
+
+    if (!challenge) throw new Error('No challenge defined');
+    if (!presentationDefinition?.input_descriptors) {
+      throw new Error('Presentation definition without input required');
+    }
+    const response = await callbacks[
+      Actor.Holder
+    ].getCredentialPresentation({
+      frame: presentationDefinition.frame,
+      inputDescriptors: presentationDefinition.input_descriptors,
+      message
+    });
+
+    if (response == CredentialPresentationResponse.AsyncProcess) {
+      return;
+    }
+
+
+    const credentialPresentation = await this.createMessage(
+      presentationDefinition,
+      challenge,
+      response.credentialsToPresent,
+      holderDID,
+      message,
+      callbacks,
+    );
+    return {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.PresentProof,
+        id: createUUID(),
+        thid: message.thid,
+        from: holderDID,
+        to: [verifierDID],
+        body: {},
+        attachments: [credentialPresentation],
+      },
+    };
+  }
+
+  private async createMessage(
+    presentationDefinition: PresentationDefinition,
+    challenge: string,
+    credentialsToPresent: any[],
+    holderDID: string,
+    message: WACIMessage,
+    callbacks: any
+  ): Promise<CredentialPresentation> {
+    const definition_id = presentationDefinition.id;
+    const descriptor_map = presentationDefinition.input_descriptors.map(
+      (descriptor, index) => ({
+        id: descriptor.id,
+        format: 'ldp_vp',
+        path: `$.verifiableCredential[${index}]`,
+      }),
+    );
+
+    const messageData = {
+      '@context': [
+        'https://extrimian.blob.core.windows.net/rskec/securityv1.jsonld',
+        'https://extrimian.blob.core.windows.net/rskec/credentialsv1.jsonld',
+        'https://extrimian.blob.core.windows.net/rskec/presentation-exchangesubmissionv1.jsonld',
+      ],
+      type: ['VerifiablePresentation', 'PresentationSubmission'],
+      holder: holderDID,
+      presentation_submission: {
+        id: createUUID(),
+        definition_id,
+        descriptor_map,
+      },
+      verifiableCredential: credentialsToPresent,
+    };
+
+    const signedData = await callbacks[Actor.Holder].signPresentation({
+      contentToSign: messageData,
+      challenge,
+      message
+    });
+
+    return {
+      id: createUUID(),
+      media_type: 'application/ld+json',
+      format: 'dif/presentation-exchange/submission@v1.0',
+      data: {
+        json: signedData,
+      },
+    } as CredentialPresentation;
+  }
+}

package/src/handlers/presentation/step-5-present-proof.handler.ts

@@ -0,0 +1,159 @@
+import { isNil } from 'lodash';
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  AckStatus,
+  Actor,
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageResponseType,
+  WACIMessageType,
+} from '../../types';
+import {
+  extractExpectedChallenge,
+  createUUID,
+  verifyPresentation,
+} from '../../utils';
+import { ProblemReportMessage } from '../../types/problem-report';
+
+@RegisterHandler(Actor.Verifier, WACIMessageType.PresentProof)
+export class PresentProofHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const messageToProcess = messageThread[messageThread.length - 1];
+
+    const holderDID = messageToProcess.from;
+    const verifierDID = messageToProcess.to[0];
+
+    const problemReport = new ProblemReportMessage();
+    const requestPresentationMessage = messageThread.find(
+      (message) => message.type === WACIMessageType.RequestPresentation,
+    );
+
+    const response = {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.PresentationAck,
+        id: createUUID(),
+        thid: messageToProcess.thid,
+        from: verifierDID,
+        to: [holderDID],
+        body: { status: undefined },
+      },
+    };
+
+    const challengeToCheck = extractExpectedChallenge(
+      requestPresentationMessage,
+    );
+
+    const presentation = messageToProcess?.attachments?.[0]?.data?.json;
+
+    const verifyPresentationResult = await callbacks[
+      Actor.Verifier
+    ].verifyPresentation({ presentation, challenge: challengeToCheck, message: messageToProcess, holderDid: holderDID });
+
+    if (!verifyPresentationResult.result) {
+      //TO DO error codes from vc suite
+      return {
+        responseType: WACIMessageResponseType.ReplyThread,
+        message: {
+          type: WACIMessageType.ProblemReport,
+          id: createUUID(),
+          thid: messageToProcess.id,
+          from: verifierDID,
+          to: [holderDID],
+          body: problemReport.presentProofMessage(
+            verifyPresentationResult.error.name,
+            verifyPresentationResult.error.description,
+          ),
+        },
+      };
+    }
+
+    const requests = requestPresentationMessage.attachments.filter(
+      (attachment) => !isNil(attachment.data.json.presentation_definition),
+    );
+
+    const submissionsToCheck = requests
+      .filter((request) => !isNil(request?.data?.json?.presentation_definition))
+      .map((request) => ({
+        presentationDefinition: request.data.json.presentation_definition,
+        submission: messageToProcess.attachments.find(
+          (attachment) =>
+            attachment?.data?.json?.presentation_submission?.definition_id ===
+            request.data.json.presentation_definition.id,
+        ),
+      }));
+
+    let result = false;
+
+    const verificationResultCallback = callbacks[Actor.Verifier].credentialVerificationResult;
+    let vcs = [];
+
+    if (
+      submissionsToCheck.every(
+        (submissionToCheck) => !isNil(submissionToCheck.submission),
+      )
+    ) {
+      for await (const submissionToCheck of submissionsToCheck) {
+
+        let verify = await verifyPresentation(
+          submissionToCheck.presentationDefinition,
+          submissionToCheck.submission,
+          callbacks[Actor.Verifier].verifyCredential
+        );
+
+        result = verify.result;
+
+        for (let vc of verify.vcs) {
+          vcs.push(vc);
+        }
+
+        if (!result) {
+
+          if (verificationResultCallback) {
+            verificationResultCallback({
+              result: verify.result,
+              error: verify.errors,
+              thid: messageToProcess.thid,
+              vcs: verify.vcs,
+              message: messageToProcess,
+            })
+          }
+
+          return {
+            responseType: WACIMessageResponseType.ReplyThread,
+            message: {
+              type: WACIMessageType.ProblemReport,
+              id: createUUID(),
+              thid: messageToProcess.id,
+              from: verifierDID,
+              to: [holderDID],
+              body: problemReport.presentProofMessage(
+                verify.error.name,
+                verify.error.description,
+              ),
+            },
+          };
+        }
+      }
+
+      if (result) {
+        if (verificationResultCallback) {
+          verificationResultCallback({
+            result: result,
+            error: null,
+            thid: messageToProcess.thid,
+            vcs: vcs,
+            message: messageToProcess,
+          })
+        }
+
+        response.message.body.status = AckStatus.Ok;
+        return response;
+      }
+    }
+  }
+}

package/src/handlers/presentation/step-6-ack-message.handler.ts

@@ -0,0 +1,15 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageType,
+  Actor,
+} from '../../types';
+
+@RegisterHandler(Actor.Holder, WACIMessageType.PresentationAck)
+export class PresentationAckMessageHandler implements WACIMessageHandler {
+  async handle(messageThread : WACIMessage[], callbacks: any) : Promise<void> {
+    const message = messageThread[messageThread.length - 1];
+    await callbacks[Actor.Holder].handlePresentationAck({ status: message.body, message });
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import './handlers/common/step-2-oob-invitation.handler';
+import './handlers/common/problem-report.handler';
+import './handlers/issuance/step-3-propose-credential.handler';
+import './handlers/issuance/step-4-offer-credential.handler';
+import './handlers/issuance/step-5-request-credential.handler';
+import './handlers/issuance/step-6-issue-credential.handler';
+import './handlers/issuance/step-7-ack-message.handler';
+import './handlers/presentation/step-3-propose-presentation.handler';
+import './handlers/presentation/step-4-request-presentation.handler';
+import './handlers/presentation/step-5-present-proof.handler';
+import './handlers/presentation/step-6-ack-message.handler';
+
+export * from "./handlers/issuance/step-3-propose-credential.handler";
+export { InputCallbacks, CredentialPresentationResponse } from './callbacks';
+export * from './services/waci-interpreter';
+export * from './types/waci-message';
+export * from './types';
+export { validateVcByInputDescriptor } from "./utils/index";