@sovrahq/waci 3.4.0

package/src/services/waci-interpreter.ts

@@ -0,0 +1,161 @@
+import { handlers } from '../handlers';
+import { InputCallbacks } from '../callbacks';
+import {
+  WACIMessageType,
+  WACIMessageTypeV1,
+  WACIMessage,
+  GoalCode,
+  Actor,
+  CredentialManifest,
+  CredentialFulfillment,
+  WACIResponse,
+  WACIMessageHandlerResponse,
+  DIDCommVersion,
+  detectDIDCommVersion,
+  normalizeToV2,
+  convertToVersion,
+} from '../types';
+import { createUUID, getObjectValues } from '../utils';
+import { SUPPORTED_ALGORITHMS } from '../constants';
+import { PresentationProceed } from '../handlers/presentation/step-4-1-presentation-proceed.handler';
+import { OfferCredentialProceed } from '../handlers/issuance/step-4-1-offer-credential-proceed.handler';
+
+export class WACIInterpreter {
+  private readonly enabledActors: Actor[];
+  private callbacks: InputCallbacks;
+
+  constructor() {
+    this.enabledActors = [];
+    this.callbacks = {};
+  }
+
+  setUpFor<T extends Actor>(
+    params: InputCallbacks[T],
+    actor: T,
+  ): WACIInterpreter {
+    this.enabledActors.push(actor);
+    this.callbacks[actor] = params;
+    return this;
+  }
+
+  isWACIMessage(messageToCheck: any): messageToCheck is WACIMessage {
+    try {
+      const allTypes = [
+        ...getObjectValues(WACIMessageType),
+        ...getObjectValues(WACIMessageTypeV1),
+      ];
+      return allTypes.includes(messageToCheck.type);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async createOOBInvitation(
+    senderDID: string,
+    goalCode: GoalCode,
+    body = {},
+    version?: DIDCommVersion,
+  ): Promise<WACIMessage> {
+    const type = version === DIDCommVersion.V1
+      ? convertToVersion(WACIMessageType.OutOfBandInvitation, DIDCommVersion.V1) as any
+      : WACIMessageType.OutOfBandInvitation;
+
+    return {
+      type,
+      id: createUUID(),
+      from: senderDID,
+      body: {
+        ...body,
+        goal_code: goalCode,
+        accept: SUPPORTED_ALGORITHMS,
+      },
+    };
+  }
+
+  async createOfferCredentialMessage(
+    issuerDID: string,
+    holderDID: string,
+    manifest: CredentialManifest,
+    fulfillment: CredentialFulfillment,
+  ): Promise<WACIMessage> {
+    return {
+      type: WACIMessageType.OfferCredential,
+      id: createUUID(),
+      from: issuerDID,
+      to: [issuerDID],
+      body: {},
+      attachments: [manifest, fulfillment],
+    };
+  }
+
+  async processMessage(
+    messageThread: WACIMessage[],
+  ): Promise<WACIResponse | void> {
+    const message = messageThread[messageThread.length - 1];
+
+    // Detect incoming version and normalize v1 → v2 for handler lookup
+    const incomingVersion = detectDIDCommVersion(message.type as string);
+    const normalizedType = normalizeToV2(message.type as string) as any;
+
+    for await (const enabledActor of this.enabledActors) {
+      const messageHandler = handlers[enabledActor].get(normalizedType);
+      if (messageHandler) {
+        // Temporarily set normalized type for the handler
+        const originalType = message.type;
+        message.type = normalizedType;
+
+        const response = await messageHandler.handle(messageThread, this.callbacks);
+
+        // Restore original type
+        message.type = originalType;
+
+        if (response) {
+          // Convert response type back to v1 if the interlocutor speaks v1
+          if (incomingVersion === DIDCommVersion.V1) {
+            response.message.type = convertToVersion(
+              response.message.type as string,
+              DIDCommVersion.V1,
+            ) as any;
+          }
+          return {
+            ...response,
+            target: response.message.to[0],
+            message: response.message,
+          };
+        }
+        return;
+      }
+    }
+
+    throw Error(`No handler found for message of type '${message.type}'`);
+  }
+
+  async presentationProceed(
+    messageThread: WACIMessage[],
+    credentialsToPresent: any[],
+    presentationProofTypes?: string[]) {
+
+    let response: WACIMessageHandlerResponse = null;
+
+    // Normalize last message type for comparison
+    const lastType = normalizeToV2(
+      messageThread[messageThread.length - 1].type as string,
+    );
+
+    if (lastType == WACIMessageType.OfferCredential) {
+      response = await OfferCredentialProceed.handle(messageThread, credentialsToPresent, presentationProofTypes, this.callbacks)
+    } else if (lastType == WACIMessageType.RequestPresentation) {
+      response = await PresentationProceed.presentCredentials(messageThread, credentialsToPresent, this.callbacks);
+    }
+
+    if (!response) {
+      throw new Error("To call this process, the message thread must end with a message of type OfferCredential or RequestPresentation.");
+    }
+
+    return {
+      ...response,
+      target: response.message.to[0],
+      message: response.message,
+    };
+  }
+}

package/src/types/actor.ts

@@ -0,0 +1,5 @@
+export enum Actor {
+  Holder = 'holder',
+  Issuer = 'issuer',
+  Verifier = 'verifier',
+}

package/src/types/credential-application.ts

@@ -0,0 +1,38 @@
+import { ClaimFormat } from './credential-manifest';
+
+export type CredentialApplication = {
+  id: string;
+  media_type: 'application/json';
+  format: 'dif/credential-manifest/application@v1.0';
+  data: {
+    json: {
+      '@context': string[];
+      type: string[];
+      credential_application: {
+        id: string;
+        manifest_id: string;
+        format?: ClaimFormat;
+      };
+      presentation_submission: PresentationSubmission;
+      verifiableCredential: any[];
+      proof: {
+        type: string;
+        verificationMethod: string;
+        created: string;
+        proofPurpose: string;
+        challenge: string;
+        jws: string;
+      };
+    };
+  };
+};
+
+export type PresentationSubmission = {
+  id: string;
+  definition_id: string;
+  descriptor_map: {
+    id: string;
+    format: string;
+    path: string;
+  }[];
+};

package/src/types/credential-manifest.ts

@@ -0,0 +1,184 @@
+import { PresentationSubmission } from './credential-application';
+
+export type CredentialManifest = {
+  id: string;
+  media_type: string;
+  format: 'dif/credential-manifest/manifest@v1.0';
+  data: {
+    json: {
+      options: {
+        challenge: string;
+        domain?: string;
+      };
+      credential_manifest: {
+        id: string;
+        version: string;
+        issuer: {
+          id: string;
+          name: string;
+          styles?: CredentialManifestStyles;
+        };
+        format?: ClaimFormat;
+        output_descriptors: OutputDescriptor[];
+        presentation_definition?: PresentationDefinition;
+      };
+    };
+  };
+};
+
+export type CredentialFulfillment = {
+  id: string;
+  media_type: 'application/json';
+  format: 'dif/credential-manifest/fulfillment@v1.0';
+  data: {
+    json: {
+      '@context': string[];
+      type: string[];
+      credential_fulfillment: {
+        id: string;
+        manifest_id: string;
+        descriptor_map: {
+          id: string;
+          format: string;
+          path: string;
+        }[];
+      };
+      verifiableCredential: any[];
+    };
+  };
+};
+
+export type CredentialRequest = {
+  id: string;
+  media_type: string;
+  format: 'dif/presentation-exchange/definitions@v1.0';
+  data: {
+    json: {
+      options: {
+        challenge: string;
+        domain?: string;
+      };
+      presentation_definition?: PresentationDefinition;
+    };
+  };
+};
+
+export type CredentialPresentation = {
+  id: string;
+  media_type: string;
+  format: 'dif/presentation-exchange/submission@v1.0';
+  data: {
+    json: {
+      '@context': string[];
+      type: string[];
+      holder: string;
+      verifiableCredential: any[];
+      presentation_submission: PresentationSubmission;
+      proof: {
+        type: string;
+        verificationMethod: string;
+        created: string;
+        proofPurpose: string;
+        challenge: string;
+        jws: string;
+      };
+    };
+  };
+};
+
+export type OutputDescriptor = {
+  id: string;
+  schema?: string;
+  display?: {
+    title?: DisplayMappingObject;
+    subtitle?: DisplayMappingObject;
+    description?: DisplayMappingObject;
+    properties?: (DisplayMappingObject & { label?: string })[];
+  };
+  styles: CredentialManifestStyles;
+};
+
+export type DisplayMappingObject =
+  | {
+    path?: string[];
+    schema?: {
+      type?: string;
+    };
+    fallback?: string;
+  }
+  | { text: string };
+
+export type ClaimFormat = {
+  jwt?: {
+    alg: string[];
+  };
+  jwt_vc?: {
+    alg: string[];
+  };
+  jwt_vp?: {
+    alg: string[];
+  };
+  ldp_vc?: {
+    proof_type: string[];
+  };
+  ldp_vp?: {
+    proof_type: string[];
+  };
+  ldp?: {
+    proof_type: string[];
+  };
+};
+
+export type PresentationDefinitionFrame = {
+  '@context': string[];
+  type: string[];
+  credentialSubject: {
+    "@explicit": boolean;
+    type: string[];
+    [key: string]: {};
+  };
+}
+
+export type PresentationDefinition = {
+  id: string;
+  input_descriptors: InputDescriptor[];
+  frame?: PresentationDefinitionFrame;
+  name?: string;
+  purpose?: string;
+  format?: ClaimFormat;
+};
+
+export type InputDescriptor = {
+  id: string;
+  constraints: {
+    fields: {
+      path: string[];
+      id?: string;
+      purpose?: string;
+      filter?: {
+        type: string;
+        const?: any;
+      };
+    }[];
+    limit_disclosure?: 'required' | 'preferred';
+  };
+  name?: string;
+  purpose?: string;
+  format?: ClaimFormat;
+};
+
+export type CredentialManifestStyles = {
+  thumbnail?: ThumbnailImage;
+  hero?: ThumbnailImage;
+  background?: ColorDefinition;
+  text?: ColorDefinition;
+}
+
+export type ColorDefinition = {
+  color: string;
+}
+
+export type ThumbnailImage = {
+  uri: string;
+  alt: string;
+}

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './actor';
+export * from './waci-message';
+export * from './credential-manifest';
+export * from './credential-application';

package/src/types/problem-report.ts

@@ -0,0 +1,29 @@
+
+
+
+export interface ProblemReportBody {
+    code: string;
+    comment?: string;
+    args?: string[];
+    escalate_to?: string;
+  }
+
+export class ProblemReportMessage{
+    code: string;
+    comment?: string;
+    args?: string[];
+    escalate_to?: string;
+
+   
+
+    presentProofMessage(code: string, comment?:string, args?: string[], escalate_to?: string): ProblemReportBody{
+        return {
+            code: code,
+            comment: comment,
+            args: args,
+            escalate_to: escalate_to
+        }
+    }
+
+   
+}

package/src/types/waci-message.ts

@@ -0,0 +1,148 @@
+enum SharedMessageType {
+  OutOfBandInvitation = 'https://didcomm.org/out-of-band/2.0/invitation',
+}
+
+enum IssuanceMessageType {
+  ProposeCredential = 'https://didcomm.org/issue-credential/3.0/propose-credential',
+  OfferCredential = 'https://didcomm.org/issue-credential/3.0/offer-credential',
+  RequestCredential = 'https://didcomm.org/issue-credential/3.0/request-credential',
+  IssueCredential = 'https://didcomm.org/issue-credential/3.0/issue-credential',
+  IssuanceAck = 'https://didcomm.org/issue-credential/3.0/ack',
+  ProblemReport = 'https://didcomm.org/report-problem/2.0/problem-report',
+}
+
+enum PresentationMessageType {
+  ProposePresentation = 'https://didcomm.org/present-proof/3.0/propose-presentation',
+  RequestPresentation = 'https://didcomm.org/present-proof/3.0/request-presentation',
+  PresentProof = 'https://didcomm.org/present-proof/3.0/presentation',
+  PresentationAck = 'https://didcomm.org/present-proof/3.0/ack',
+  ProblemReport = 'https://didcomm.org/report-problem/2.0/problem-report',
+}
+
+// --- DIDComm v1 message types ---
+
+enum SharedMessageTypeV1 {
+  OutOfBandInvitation = 'https://didcomm.org/out-of-band/1.0/invitation',
+}
+
+enum IssuanceMessageTypeV1 {
+  ProposeCredential = 'https://didcomm.org/issue-credential/1.0/propose-credential',
+  OfferCredential = 'https://didcomm.org/issue-credential/1.0/offer-credential',
+  RequestCredential = 'https://didcomm.org/issue-credential/1.0/request-credential',
+  IssueCredential = 'https://didcomm.org/issue-credential/1.0/issue-credential',
+  IssuanceAck = 'https://didcomm.org/issue-credential/1.0/ack',
+  ProblemReport = 'https://didcomm.org/report-problem/1.0/problem-report',
+}
+
+enum PresentationMessageTypeV1 {
+  ProposePresentation = 'https://didcomm.org/present-proof/1.0/propose-presentation',
+  RequestPresentation = 'https://didcomm.org/present-proof/1.0/request-presentation',
+  PresentProof = 'https://didcomm.org/present-proof/1.0/presentation',
+  PresentationAck = 'https://didcomm.org/present-proof/1.0/ack',
+  ProblemReport = 'https://didcomm.org/report-problem/1.0/problem-report',
+}
+
+export const WACIMessageTypeV1 = {
+  ...SharedMessageTypeV1,
+  ...IssuanceMessageTypeV1,
+  ...PresentationMessageTypeV1,
+};
+
+// --- Version detection & normalization ---
+
+export enum DIDCommVersion {
+  V1 = 'v1',
+  V2 = 'v2',
+}
+
+const V1_TO_V2_MAP: Record<string, string> = {
+  [SharedMessageTypeV1.OutOfBandInvitation]: SharedMessageType.OutOfBandInvitation,
+  [IssuanceMessageTypeV1.ProposeCredential]: IssuanceMessageType.ProposeCredential,
+  [IssuanceMessageTypeV1.OfferCredential]: IssuanceMessageType.OfferCredential,
+  [IssuanceMessageTypeV1.RequestCredential]: IssuanceMessageType.RequestCredential,
+  [IssuanceMessageTypeV1.IssueCredential]: IssuanceMessageType.IssueCredential,
+  [IssuanceMessageTypeV1.IssuanceAck]: IssuanceMessageType.IssuanceAck,
+  [IssuanceMessageTypeV1.ProblemReport]: IssuanceMessageType.ProblemReport,
+  [PresentationMessageTypeV1.ProposePresentation]: PresentationMessageType.ProposePresentation,
+  [PresentationMessageTypeV1.RequestPresentation]: PresentationMessageType.RequestPresentation,
+  [PresentationMessageTypeV1.PresentProof]: PresentationMessageType.PresentProof,
+  [PresentationMessageTypeV1.PresentationAck]: PresentationMessageType.PresentationAck,
+  // ProblemReport v1 already mapped via IssuanceMessageTypeV1.ProblemReport (same URI)
+};
+
+const V2_TO_V1_MAP: Record<string, string> = Object.fromEntries(
+  Object.entries(V1_TO_V2_MAP).map(([k, v]) => [v, k]),
+);
+
+export function detectDIDCommVersion(type: string): DIDCommVersion {
+  if (/\/1\.0\//.test(type)) return DIDCommVersion.V1;
+  return DIDCommVersion.V2;
+}
+
+export function normalizeToV2(type: string): string {
+  return V1_TO_V2_MAP[type] || type;
+}
+
+export function convertToVersion(type: string, target: DIDCommVersion): string {
+  if (target === DIDCommVersion.V1) {
+    return V2_TO_V1_MAP[type] || type;
+  }
+  return V1_TO_V2_MAP[type] || type;
+}
+
+export const WACIMessageType = {
+  ...SharedMessageType,
+  ...IssuanceMessageType,
+  ...PresentationMessageType,
+};
+
+// eslint-disable-next-line no-redeclare
+export type WACIMessageType =
+  | SharedMessageType
+  | IssuanceMessageType
+  | PresentationMessageType;
+
+export enum GoalCode {
+  Issuance = 'streamlined-vc',
+  Presentation = 'streamlined-vp',
+}
+
+export const enum AckStatus {
+  Ok = 'OK',
+  Fail = 'FAIL',
+  Pending = 'PENDING',
+}
+
+export type WACIMessage = {
+  type: WACIMessageType;
+  id: string;
+  from: string;
+  to?: string[];
+  body?: any;
+  pthid?: string;
+  thid?: string;
+  attachments?: any[];
+};
+
+export const enum WACIMessageResponseType {
+  CreateThread,
+  ReplyThread,
+}
+
+export type WACIMessageHandlerResponse = {
+  message: WACIMessage;
+  responseType: WACIMessageResponseType;
+};
+
+export type WACIResponse = {
+  message: WACIMessage;
+  target: string;
+  responseType: WACIMessageResponseType;
+};
+
+export interface WACIMessageHandler {
+  handle(
+    messageThread: WACIMessage[],
+    callbacks: any,
+  ): Promise<WACIMessageHandlerResponse | void>;
+}

package/src/utils/erros.ts

@@ -0,0 +1,21 @@
+export enum WaciErrorCode {
+    InputDescriptorError = 30
+  }
+  
+  export class WaciMessageError {
+    code: number;
+    name: string;
+    description: string;
+  
+    constructor(description?: string) { this.description = description; }
+  }
+  
+  export class InputDescriptorError extends WaciMessageError {
+    code = WaciErrorCode.InputDescriptorError;
+    name = "input-descriptor-not-found";
+  
+    constructor(private messageError?: string) {
+      super(messageError);
+    }
+  }
+