@sovrahq/waci 3.4.0

package/src/handlers/issuance/step-3-propose-credential.handler.ts

@@ -0,0 +1,186 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageResponseType,
+  WACIMessageType,
+  Actor,
+  CredentialManifest,
+  CredentialFulfillment,
+  PresentationDefinition,
+  InputDescriptor,
+  OutputDescriptor,
+  PresentationDefinitionFrame,
+} from '../../types';
+import { createUUID } from '../../utils';
+import { ProblemReportMessage } from '../../types/problem-report';
+
+export type OfferCredentialMessageParamsBase =
+  | OfferCredentialMessageParams
+  | OfferCredentialMessageParamsFailed
+  | OfferCredentialMessageParamsAsyncProcess;
+
+export type OfferCredentialMessageParams = {
+  issuerDid: string;
+  issuerName: string;
+  issuerStyles: any;
+  output: {
+    outputDescriptor: OutputDescriptor;
+    verifiableCredential: any;
+    //Verificar de donde sale este dato
+    format: 'ldp_vc' | '';
+  }[];
+  input?: InputDescriptor[];
+  frame?: PresentationDefinitionFrame;
+  result?: OfferCredentialMessageResult.Succeded;
+};
+
+export type OfferCredentialMessageParamsFailed = {
+  result?: OfferCredentialMessageResult.Failed;
+  errorMessage?: string;
+};
+
+export type OfferCredentialMessageParamsAsyncProcess = {
+  result?: OfferCredentialMessageResult.AsyncProcess;
+  errorMessage?: string;
+};
+
+@RegisterHandler(Actor.Issuer, WACIMessageType.ProposeCredential)
+export class ProposeCredentialHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+    const holderDID = message.from;
+    const issuerDID = message.to[0];
+    const invitationId = message.pthid;
+    const credentialManifestParams = await callbacks[
+      Actor.Issuer
+    ].getCredentialManifest({
+      invitationId: invitationId,
+      holderDid: holderDID,
+      message,
+    });
+
+    credentialManifestParams.result =
+      credentialManifestParams.result || OfferCredentialMessageResult.Succeded;
+
+    if (
+      credentialManifestParams.result == OfferCredentialMessageResult.Succeded
+    ) {
+      const credentialManifest = this.createMessage(credentialManifestParams);
+
+      return {
+        responseType: WACIMessageResponseType.ReplyThread,
+        message: {
+          type: WACIMessageType.OfferCredential,
+          id: createUUID(),
+          thid: message.id,
+          from: issuerDID,
+          to: [holderDID],
+          body: {},
+          attachments: credentialManifest,
+        },
+      };
+    } else if (
+      credentialManifestParams.result == OfferCredentialMessageResult.Failed
+    ) {
+      const problemReport = new ProblemReportMessage();
+
+      return {
+        responseType: WACIMessageResponseType.ReplyThread,
+        message: {
+          type: WACIMessageType.ProblemReport,
+          id: createUUID(),
+          thid: message.id,
+          from: issuerDID,
+          to: [holderDID],
+          body: problemReport.presentProofMessage(
+            "credential_issuance_error",
+            credentialManifestParams.errorMessage,
+          ),
+        },
+      };
+    }
+
+    //If credentialManifestParams.result == OfferCredentialMessageResult.AsyncProcess do nothing
+  }
+
+  private createMessage(
+    params: OfferCredentialMessageParams,
+  ): (CredentialManifest | CredentialFulfillment)[] {
+    const manifestId = createUUID();
+    const presentationDefinition: PresentationDefinition = params.input?.length
+      ? {
+        id: createUUID(),
+        input_descriptors: params.input,
+        frame: params.frame,
+      }
+      : undefined;
+
+
+    return [
+      {
+        id: createUUID(),
+        media_type: 'application/json',
+        format: 'dif/credential-manifest/manifest@v1.0',
+        data: {
+          json: {
+            options: {
+              challenge: createUUID(),
+            },
+            credential_manifest: {
+              id: manifestId,
+              version: '0.1.0',
+              issuer: {
+                id: params.issuerDid,
+                name: params.issuerName,
+                styles: params.issuerStyles
+              },
+              presentation_definition: presentationDefinition,
+              output_descriptors: params.output.map(
+                (descriptors) => descriptors.outputDescriptor,
+              ),
+            },
+          },
+        },
+      },
+      {
+        id: createUUID(),
+        media_type: 'application/json',
+        format: 'dif/credential-manifest/fulfillment@v1.0',
+        data: {
+          json: {
+            '@context': [
+              'https://extrimian.blob.core.windows.net/rskec/credentialsv1.jsonld',
+              'https://extrimian.blob.core.windows.net/rskec/credential-manifestfulfillmentv1.jsonld',
+            ],
+            type: ['VerifiablePresentation', 'CredentialFulfillment'],
+            credential_fulfillment: {
+              id: createUUID(),
+              manifest_id: manifestId,
+              descriptor_map: params.output.map((descriptor, index) => {
+                return {
+                  id: descriptor.outputDescriptor.id,
+                  format: descriptor.format || 'ldp_vp',
+                  path: `$.verifiableCredential[${index}]`,
+                };
+              }),
+            },
+            verifiableCredential: params.output.map(
+              (vcData) => vcData.verifiableCredential,
+            ),
+          },
+        },
+      },
+    ];
+  }
+}
+
+export enum OfferCredentialMessageResult {
+  Succeded,
+  Failed,
+  AsyncProcess,
+}

package/src/handlers/issuance/step-4-1-offer-credential-proceed.handler.ts

@@ -0,0 +1,129 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageType,
+  WACIMessageResponseType,
+  Actor,
+  CredentialApplication,
+  CredentialManifest,
+  CredentialFulfillment,
+} from '../../types';
+import { createUUID } from '../../utils';
+import { isNil } from 'lodash';
+
+export class OfferCredentialProceed {
+  static async handle(
+    messageThread: WACIMessage[],
+    credentialsToPresent: any[],
+    presentationProofTypes: string[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+    const holderDID = message.to[0];
+    const issuerDID = message.from;
+
+    const credentialApplicationParams = {
+      manifest: message.attachments.find(
+        (attachment) => !isNil(attachment?.data?.json?.credential_manifest),
+      ) as CredentialManifest,
+      fulfillment: message.attachments.find(
+        (attachment) => !isNil(attachment?.data?.json?.credential_fulfillment),
+      ) as CredentialFulfillment,
+      message
+    };
+
+    if (!credentialApplicationParams.manifest)
+      throw new Error('Malformed offer credential message');
+
+    const credentialApplication = await this.createMessage(
+      credentialsToPresent,
+      presentationProofTypes,
+      credentialApplicationParams.manifest,
+      message,
+      callbacks,
+    );
+
+    return {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.RequestCredential,
+        id: createUUID(),
+        thid: message.thid,
+        from: holderDID,
+        to: [issuerDID],
+        body: {},
+
+        attachments: credentialApplication ? [credentialApplication] : [],
+      },
+    };
+  }
+
+  private static async createMessage(
+    verifiableCredential: any[],
+    proofTypes: string[],
+    manifest: CredentialManifest,
+    message: WACIMessage,
+    callbacks: any
+  ): Promise<CredentialApplication> {
+    const credential_manifest = manifest?.data?.json?.credential_manifest;
+    const manifest_id = credential_manifest?.id;
+    const presentation_definition =
+      credential_manifest?.presentation_definition;
+    const definition_id = presentation_definition?.id;
+    const input_descriptors = presentation_definition?.input_descriptors;
+    const challenge = manifest?.data?.json?.options?.challenge;
+
+    if (!challenge) throw new Error('No challenge defined');
+    if (!input_descriptors?.length) return;
+
+    const descriptor_map = input_descriptors?.map((descriptor, index) => ({
+      id: descriptor.id,
+      format: 'ldp_vp',
+      path: `$.verifiableCredential[${index}]`,
+    }));
+
+    if (!proofTypes?.length) throw new Error('Proof types need to be defined');
+    if (!manifest_id) throw new Error('Malformed credential manifest');
+
+    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/credential-manifestapplicationv1.jsonld',
+      ],
+      type: ['VerifiablePresentation', 'CredentialApplication'],
+      credential_application: {
+        id: createUUID(),
+        manifest_id,
+        format: {
+          ldp_vc: {
+            proof_type: proofTypes,
+          },
+        },
+      },
+      presentation_submission: {
+        id: createUUID(),
+        definition_id,
+        descriptor_map,
+      },
+      verifiableCredential,
+    };
+
+    const signedData = await callbacks[Actor.Holder].signPresentation({
+      contentToSign: messageData,
+      challenge,
+      message
+    });
+
+    return {
+      id: createUUID(),
+      media_type: 'application/json',
+      format: 'dif/credential-manifest/application@v1.0',
+      data: {
+        json: signedData,
+      },
+    } as CredentialApplication;
+  }
+}

package/src/handlers/issuance/step-4-offer-credential.handler.ts

@@ -0,0 +1,137 @@
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageType,
+  WACIMessageResponseType,
+  Actor,
+  CredentialApplication,
+  CredentialManifest,
+  CredentialFulfillment,
+} from '../../types';
+import { createUUID } from '../../utils';
+import { CredentialPresentationResponse } from '../../callbacks';
+import { isNil } from 'lodash';
+
+@RegisterHandler(Actor.Holder, WACIMessageType.OfferCredential)
+export class OfferCredentialHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse> {
+    const message = messageThread[messageThread.length - 1];
+    const holderDID = message.to[0];
+    const issuerDID = message.from;
+
+    const credentialApplicationParams = {
+      manifest: message.attachments.find(
+        (attachment) => !isNil(attachment?.data?.json?.credential_manifest),
+      ) as CredentialManifest,
+      fulfillment: message.attachments.find(
+        (attachment) => !isNil(attachment?.data?.json?.credential_fulfillment),
+      ) as CredentialFulfillment,
+      message
+    };
+
+    if (!credentialApplicationParams.manifest)
+      throw new Error('Malformed offer credential message');
+
+    const response = await callbacks[
+      Actor.Holder
+    ].getCredentialApplication(credentialApplicationParams);
+
+    if (response == CredentialPresentationResponse.AsyncProcess) {
+      return;
+    }
+
+    const credentialApplication = await this.createMessage(
+      response.credentialsToPresent,
+      response.presentationProofTypes,
+      credentialApplicationParams.manifest,
+      message,
+      callbacks,
+    );
+
+    return {
+      responseType: WACIMessageResponseType.ReplyThread,
+      message: {
+        type: WACIMessageType.RequestCredential,
+        id: createUUID(),
+        thid: message.thid,
+        from: holderDID,
+        to: [issuerDID],
+        body: {},
+
+        attachments: credentialApplication ? [credentialApplication] : [],
+      },
+    };
+  }
+
+  private async createMessage(
+    verifiableCredential: any[],
+    proofTypes: string[],
+    manifest: CredentialManifest,
+    message: WACIMessage,
+    callbacks: any
+  ): Promise<CredentialApplication> {
+    const credential_manifest = manifest?.data?.json?.credential_manifest;
+    const manifest_id = credential_manifest?.id;
+    const presentation_definition =
+      credential_manifest?.presentation_definition;
+    const definition_id = presentation_definition?.id;
+    const input_descriptors = presentation_definition?.input_descriptors;
+    const challenge = manifest?.data?.json?.options?.challenge;
+
+    if (!challenge) throw new Error('No challenge defined');
+    if (!input_descriptors?.length) return;
+
+    const descriptor_map = input_descriptors?.map((descriptor, index) => ({
+      id: descriptor.id,
+      format: 'ldp_vp',
+      path: `$.verifiableCredential[${index}]`,
+    }));
+
+    if (!proofTypes?.length) throw new Error('Proof types need to be defined');
+    if (!manifest_id) throw new Error('Malformed credential manifest');
+
+    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/credential-manifestapplicationv1.jsonld',
+      ],
+      type: ['VerifiablePresentation', 'CredentialApplication'],
+      credential_application: {
+        id: createUUID(),
+        manifest_id,
+        format: {
+          ldp_vc: {
+            proof_type: proofTypes,
+          },
+        },
+      },
+      presentation_submission: {
+        id: createUUID(),
+        definition_id,
+        descriptor_map,
+      },
+      verifiableCredential,
+    };
+
+    const signedData = await callbacks[Actor.Holder].signPresentation({
+      contentToSign: messageData,
+      challenge,
+      message
+    });
+
+    return {
+      id: createUUID(),
+      media_type: 'application/json',
+      format: 'dif/credential-manifest/application@v1.0',
+      data: {
+        json: signedData,
+      },
+    } as CredentialApplication;
+  }
+}

package/src/handlers/issuance/step-5-request-credential.handler.ts

@@ -0,0 +1,205 @@
+import { isNil } from 'lodash';
+import { RegisterHandler } from '../decorators/register-handler.decorator';
+import {
+  WACIMessage,
+  WACIMessageHandler,
+  WACIMessageHandlerResponse,
+  WACIMessageType,
+  WACIMessageResponseType,
+  Actor,
+  CredentialManifest,
+  CredentialFulfillment,
+} from '../../types';
+import {
+  extractExpectedChallenge,
+  createUUID,
+  verifyPresentation,
+} from '../../utils';
+import { ProblemReportMessage } from '../../types/problem-report';
+
+@RegisterHandler(Actor.Issuer, WACIMessageType.RequestCredential)
+export class RequestCredentialHandler implements WACIMessageHandler {
+  async handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse | void> {
+    const messageToProcess = messageThread[messageThread.length - 1];
+    const holderDID = messageToProcess.from;
+    const issuerDID = messageToProcess.to[0];
+    const problemReport = new ProblemReportMessage();
+    const offerCredentialMessage = messageThread.find(
+      (message) => message.type === WACIMessageType.OfferCredential,
+    );
+
+    try {
+      const manifests: CredentialManifest[] =
+        offerCredentialMessage.attachments.filter(
+          (attachment) => !isNil(attachment?.data?.json?.credential_manifest),
+        );
+
+      const applicationsToCheck = manifests
+        .filter(
+          (manifest) =>
+            !isNil(
+              manifest?.data?.json?.credential_manifest?.presentation_definition,
+            ),
+        )
+        .map((manifest) => ({
+          presentationDefinition:
+            manifest.data.json.credential_manifest.presentation_definition,
+          application: messageToProcess.attachments.find(
+            (attachment) =>
+              attachment.data.json.credential_application.manifest_id ===
+              manifest.data.json.credential_manifest.id,
+          ),
+        }));
+
+      const verificationResultCallback = callbacks[Actor.Issuer]?.credentialVerificationResult;
+      let vcs = [];
+
+      if (
+        applicationsToCheck.every((applicationToCheck) =>
+          !isNil(applicationToCheck.application),
+        )
+      ) {
+        for await (const applicationToCheck of applicationsToCheck) {
+          const verify = await verifyPresentation(
+            applicationToCheck.presentationDefinition,
+            applicationToCheck.application,
+            callbacks[Actor.Issuer].verifyCredential,
+          );
+          let result = verify.result;
+
+          for (let vc of verify.vcs) {
+            vcs.push(vc);
+          }
+
+          if (!result) {
+            if (verificationResultCallback) {
+              verificationResultCallback({
+                result: verify.result,
+                error: verify.erorrs,
+                thid: messageToProcess.thid,
+                vcs: verify.vcs,
+                message: messageToProcess,
+              })
+            }
+
+            return {
+              responseType: WACIMessageResponseType.ReplyThread,
+              message: {
+                type: WACIMessageType.ProblemReport,
+                id: createUUID(),
+                thid: messageToProcess.id,
+                from: issuerDID,
+                to: [holderDID],
+                body: problemReport.presentProofMessage(
+                  verify.error.name,
+                  verify.error.description,
+                ),
+              },
+            };
+          }
+
+          if (applicationsToCheck.length) {
+            const challengeToCheck = extractExpectedChallenge(
+              offerCredentialMessage,
+            );
+
+            const presentation = messageToProcess.attachments[0].data.json;
+            const verifyPresentationResult = await callbacks[
+              Actor.Issuer
+            ].verifyPresentation({ presentation, challenge: challengeToCheck, message: messageToProcess, holderDid: holderDID });
+            if (!verifyPresentationResult.result) {
+              return {
+                responseType: WACIMessageResponseType.ReplyThread,
+                message: {
+                  type: WACIMessageType.ProblemReport,
+                  id: createUUID(),
+                  thid: messageToProcess.id,
+                  from: issuerDID,
+                  to: [holderDID],
+                  body: problemReport.presentProofMessage(
+                    verifyPresentationResult.error.name,
+                    verifyPresentationResult.error.description,
+                  ),
+                },
+              };
+            }
+
+          }
+        }
+
+        if (verificationResultCallback) {
+          verificationResultCallback({
+            result: true,
+            error: null,
+            thid: messageToProcess.thid,
+            vcs: vcs,
+            message: messageToProcess,
+          })
+        }
+      }
+
+
+      const fulfillments: CredentialFulfillment[] =
+        offerCredentialMessage.attachments.filter(
+          (attachment) =>
+            !isNil(attachment?.data?.json?.credential_fulfillment),
+        );
+
+      let attachments = [];
+
+      for (let f of fulfillments) {
+        const attachment = {
+          id: createUUID(),
+          media_type: 'application/json',
+          format: 'dif/credential-manifest/fulfillment@v1.0',
+          data: {
+            json: {
+              ...f.data.json,
+            },
+          },
+        };
+        attachment.data.json.verifiableCredential = [];
+
+        for (let vc of f.data.json.verifiableCredential) {
+          attachment.data.json.verifiableCredential.push(await callbacks[Actor.Issuer].signCredential({ vc: vc, message: messageToProcess }));
+        }
+
+        attachments.push(attachment);
+      }
+
+      return {
+        responseType: WACIMessageResponseType.ReplyThread,
+        message: {
+          type: WACIMessageType.IssueCredential,
+          id: createUUID(),
+          thid: messageToProcess.thid,
+          from: issuerDID,
+          to: [holderDID],
+          body: {},
+          attachments: attachments,
+        },
+      };
+    }
+    catch (ex) {
+      return {
+        responseType: WACIMessageResponseType.ReplyThread,
+        message: {
+          type: WACIMessageType.ProblemReport,
+          id: createUUID(),
+          thid: messageToProcess.id,
+          from: issuerDID,
+          to: [holderDID],
+          body: problemReport.presentProofMessage(
+            'unexpected-error',
+            'Unexpected error: ' + ex?.message,
+          )
+        },
+      }
+    }
+  }
+}
+
+