@extrimian/agent 0.12.0-10 → 0.12.0-11

package/dist/vc/protocols/vc-protocol.d.ts

@@ -0,0 +1,106 @@
+import { VerifiableCredential } from "@extrimian/vc-core";
+import { Agent } from "../../agent";
+import { DID } from "../../models/did";
+import { LiteEvent } from "../../utils/lite-event";
+import { CredentialFlow } from "../models/credentia-flow";
+import { IssuerData, VerifiableCredentialWithInfo } from "./waci-protocol";
+export declare enum ActorRole {
+    Issuer = 0,
+    Holder = 1,
+    Verifier = 2
+}
+export declare abstract class VCProtocol<TProtocolMessage = any> {
+    protected readonly onVcArrived: LiteEvent<{
+        credentials: VerifiableCredentialWithInfo[];
+        issuer: IssuerData;
+        messageId: string;
+    }>;
+    get vcArrived(): import("../../utils/lite-event").ILiteEvent<{
+        credentials: VerifiableCredentialWithInfo[];
+        issuer: IssuerData;
+        messageId: string;
+    }>;
+    protected readonly onCredentialIssued: LiteEvent<{
+        vc: VerifiableCredential;
+        toDID: DID;
+        invitationId?: string;
+    }>;
+    get credentialIssued(): import("../../utils/lite-event").ILiteEvent<{
+        vc: VerifiableCredential<any>;
+        toDID: DID;
+        invitationId?: string;
+    }>;
+    protected readonly onVcVerified: LiteEvent<{
+        verified: boolean;
+        presentationVerified: boolean;
+        vc: VerifiableCredential;
+    }>;
+    get vcVerified(): import("../../utils/lite-event").ILiteEvent<{
+        verified: boolean;
+        presentationVerified: boolean;
+        vc: VerifiableCredential<any>;
+    }>;
+    protected readonly onPresentationVerified: LiteEvent<{
+        verified: boolean;
+        vcs: VerifiableCredential[];
+        thid: string;
+        invitationId: string;
+        rejectMsg?: string;
+        messageId: string;
+    }>;
+    get presentationVerified(): import("../../utils/lite-event").ILiteEvent<{
+        verified: boolean;
+        vcs: VerifiableCredential<any>[];
+        thid: string;
+        invitationId: string;
+        rejectMsg?: string;
+        messageId: string;
+    }>;
+    protected readonly onAckCompleted: LiteEvent<{
+        role: ActorRole;
+        status: string;
+        messageId: string;
+        thid: string;
+        invitationId?: string;
+    }>;
+    get ackCompleted(): import("../../utils/lite-event").ILiteEvent<{
+        role: ActorRole;
+        status: string;
+        messageId: string;
+        thid: string;
+        invitationId?: string;
+    }>;
+    protected readonly onProblemReport: LiteEvent<{
+        did: DID;
+        code: string;
+        codeMessage: string;
+        invitationId: string;
+        messageId: string;
+    }>;
+    get problemReport(): import("../../utils/lite-event").ILiteEvent<{
+        did: DID;
+        code: string;
+        codeMessage: string;
+        invitationId: string;
+        messageId: string;
+    }>;
+    abstract processMessage(message: TProtocolMessage, context?: any, did?: DID): Promise<VCProtocolResponse | void>;
+    abstract isProtocolMessage(message: any): Promise<boolean>;
+    abstract createInvitationMessage(flow: CredentialFlow, did: DID): Promise<TProtocolMessage>;
+    protected agent: Agent;
+    constructor();
+    initialize(params: {
+        agent: Agent;
+    }): void;
+}
+export declare enum VCMessageType {
+    RequestCredential = 0
+}
+export interface CredentialRequestedEventArg<TProtocolMessage = any> {
+    did: string;
+    protocolMessage: TProtocolMessage;
+}
+export interface VCProtocolResponse {
+    to: DID;
+    message: any;
+}

package/dist/vc/protocols/vc-protocol.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VCMessageType = exports.VCProtocol = exports.ActorRole = void 0;
+const lite_event_1 = require("../../utils/lite-event");
+var ActorRole;
+(function (ActorRole) {
+    ActorRole[ActorRole["Issuer"] = 0] = "Issuer";
+    ActorRole[ActorRole["Holder"] = 1] = "Holder";
+    ActorRole[ActorRole["Verifier"] = 2] = "Verifier";
+})(ActorRole = exports.ActorRole || (exports.ActorRole = {}));
+class VCProtocol {
+    get vcArrived() { return this.onVcArrived.expose(); }
+    get credentialIssued() { return this.onCredentialIssued.expose(); }
+    get vcVerified() { return this.onVcVerified.expose(); }
+    get presentationVerified() { return this.onPresentationVerified.expose(); }
+    get ackCompleted() { return this.onAckCompleted.expose(); }
+    get problemReport() { return this.onProblemReport.expose(); }
+    constructor() {
+        // protected readonly onCredentialRequested = new LiteEvent<CredentialRequestedEventArg>;
+        // public get credentialRequested() { return this.onCredentialRequested.expose(); }
+        this.onVcArrived = new lite_event_1.LiteEvent;
+        this.onCredentialIssued = new lite_event_1.LiteEvent;
+        this.onVcVerified = new lite_event_1.LiteEvent;
+        this.onPresentationVerified = new lite_event_1.LiteEvent;
+        this.onAckCompleted = new lite_event_1.LiteEvent;
+        this.onProblemReport = new lite_event_1.LiteEvent;
+    }
+    initialize(params) {
+        this.agent = params.agent;
+    }
+}
+exports.VCProtocol = VCProtocol;
+var VCMessageType;
+(function (VCMessageType) {
+    VCMessageType[VCMessageType["RequestCredential"] = 0] = "RequestCredential";
+})(VCMessageType = exports.VCMessageType || (exports.VCMessageType = {}));
+//# sourceMappingURL=vc-protocol.js.map

package/dist/vc/protocols/vc-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vc-protocol.js","sourceRoot":"","sources":["../../../src/vc/protocols/vc-protocol.ts"],"names":[],"mappings":";;;AAKA,uDAAmD;AAInD,IAAY,SAIX;AAJD,WAAY,SAAS;IACjB,6CAAM,CAAA;IACN,6CAAM,CAAA;IACN,iDAAQ,CAAA;AACZ,CAAC,EAJW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAIpB;AAED,MAAsB,UAAU;IAK5B,IAAW,SAAS,KAAK,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAG5D,IAAW,gBAAgB,KAAK,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAG1E,IAAW,UAAU,KAAK,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAG9D,IAAW,oBAAoB,KAAK,OAAO,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAGlF,IAAW,YAAY,KAAK,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAGlE,IAAW,aAAa,KAAK,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IASpE;QA5BA,yFAAyF;QACzF,mFAAmF;QAEhE,gBAAW,GAAG,IAAI,sBAAiG,CAAC;QAGpH,uBAAkB,GAAG,IAAI,sBAA0E,CAAC;QAGpG,iBAAY,GAAG,IAAI,sBAAyF,CAAC;QAG7G,2BAAsB,GAAG,IAAI,sBAAwI,CAAC;QAGtK,mBAAc,GAAG,IAAI,sBAAsG,CAAC;QAG5H,oBAAe,GAAG,IAAI,sBAAmG,CAAC;IAY7I,CAAC;IAED,UAAU,CAAC,MAEV;QACG,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC9B,CAAC;CACJ;AAtCD,gCAsCC;AAED,IAAY,aAEX;AAFD,WAAY,aAAa;IACrB,2EAAiB,CAAA;AACrB,CAAC,EAFW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAExB"}

package/dist/vc/protocols/waci-protocol.d.ts

@@ -0,0 +1,183 @@
+import { Issuer, UnsignedCredential, VerifiableCredential } from "@extrimian/vc-core";
+import { ClaimFormat, CredentialManifestStyles, DisplayMappingObject, GoalCode, InputDescriptor, OutputDescriptor, PresentationDefinition, PresentationDefinitionFrame, WACIMessage } from "@extrimian/waci";
+import { Agent } from "../../agent";
+import { IStorage } from "../../models/agent-storage";
+import { DID } from "../../models/did";
+import { CredentialFlow } from "../models/credentia-flow";
+import { VCProtocol, VCProtocolResponse } from "./vc-protocol";
+export declare class WACIProtocol extends VCProtocol<WACIMessage> {
+    private waciInterpreter;
+    private storage;
+    issueCredentials: (waciInvitationId: string, holderDID: string) => Promise<WACICredentialOfferResponse>;
+    issuerVerificationRules?: (waciInvitationId: string, holdedDID: string) => Promise<IssuerVerificationRuleResult>;
+    selectVcToPresent?: (vcs: VerifiableCredential[]) => Promise<VerifiableCredential[]>;
+    presentationDefinition?: (invitationId: string) => Promise<{
+        inputDescriptors: InputDescriptor[];
+        frame?: PresentationDefinitionFrame;
+    }>;
+    credentialApplication?: (inputs: {
+        descriptor: InputDescriptor;
+        credentials: VerifiableCredentialWithInfo[];
+    }[], selectiveDisclosure?: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: VerifiableCredentialWithInfo[]) => Promise<VerifiableCredential[]>;
+    credentialApplicationAsync: (inputs: {
+        descriptor: InputDescriptor;
+        credentials: VerifiableCredentialWithInfo[];
+    }[], invitationId: string, selectiveDisclosure?: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: VerifiableCredentialWithInfo[]) => Promise<void>;
+    businessVerificationRules?: (invitationId: string, holderDID: DID, vcs: VerifiableCredential[]) => Promise<BusinessRulesVerificationResult>;
+    constructor(params?: {
+        issuer?: {
+            issueCredentials?: (waciInvitationId: string, holderDID: string) => Promise<WACICredentialOfferResponse>;
+            issuerVerificationRules?: (waciInvitationId: string, holdedDID: string) => Promise<IssuerVerificationRuleResult>;
+        };
+        holder?: {
+            selectVcToPresent?: (vcs: VerifiableCredential[]) => Promise<VerifiableCredential[]>;
+            credentialApplication?: (inputs: {
+                descriptor: InputDescriptor;
+                credentials: VerifiableCredentialWithInfo[];
+            }[], selectiveDisclosure: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: {
+                data: VerifiableCredential;
+                styles: CredentialManifestStyles;
+                display: CredentialDisplay;
+            }[]) => Promise<VerifiableCredential[]>;
+            credentialApplicationAsync?: (inputs: {
+                descriptor: InputDescriptor;
+                credentials: VerifiableCredentialWithInfo[];
+            }[], invitationId: string, selectiveDisclosure: SelectiveDisclosure, message?: WACIMessage, issuer?: (Issuer | CredentialManifestStyles), credentialsToReceive?: {
+                data: VerifiableCredential;
+                styles: CredentialManifestStyles;
+                display: CredentialDisplay;
+            }[]) => Promise<void>;
+        };
+        verifier?: {
+            presentationDefinition?: (invitationId: string) => Promise<{
+                inputDescriptors: InputDescriptor[];
+                frame?: PresentationDefinitionFrame;
+            }>;
+            businessVerificationRules?: (invitationId: string, holderDID: DID, vcs: VerifiableCredential[]) => Promise<BusinessRulesVerificationResult>;
+        };
+        storage: IStorage;
+    });
+    initialize(params: {
+        agent: Agent;
+    }): void;
+    presentationProceed(invitationId: string, credentialsToPresent: VerifiableCredential[]): Promise<{
+        to: DID;
+        from: DID;
+        message: import("@extrimian/kms-core").DIDCommPackedMessage;
+    }>;
+    processMessage(message: WACIMessage | string, context?: any, did?: DID): Promise<VCProtocolResponse | void>;
+    createOBBInvitation(goalCode: GoalCode, did: DID): Promise<WACIMessage>;
+    createInvitationMessage(flow: CredentialFlow, did: DID): Promise<WACIMessage>;
+    isProtocolMessage(message: any): Promise<boolean>;
+    private decodeMessage;
+    private validateSchema;
+}
+export declare enum WACIRequest {
+    CredentialManifestRequested = 0
+}
+export declare enum InternalStorageEnum {
+    CredentialManifests = "CredentialManifests"
+}
+export type VerifiableCredentialWithInfo = {
+    data: VerifiableCredential;
+    styles?: CredentialManifestStyles;
+    display?: CredentialDisplay;
+};
+export declare class SelectiveDisclosure {
+    allFieldsToReveal: string[];
+    credentialSubjectFieldsToReveal: string[];
+    constructor();
+    static from(frame: any, outputDescriptors: any[]): SelectiveDisclosure;
+}
+export type SelectiveDisclosureField = {
+    id: string;
+};
+export type CredentialManifestData = {
+    id: string;
+    version: string;
+    issuer: IssuerData;
+    format?: ClaimFormat;
+    output_descriptors: OutputDescriptor[];
+    presentation_definition?: PresentationDefinition;
+};
+export type IssuerData = {
+    id: string;
+    name: string;
+    styles?: CredentialManifestStyles;
+};
+export type CredentialDisplay = {
+    title?: DisplayMappingObject;
+    subtitle?: DisplayMappingObject;
+    description?: DisplayMappingObject;
+    properties?: (DisplayMappingObject & {
+        label?: string;
+    })[];
+};
+export declare class WACIEventArg {
+    request: WACIRequest;
+}
+export declare class CredentialRequestedEventArg extends WACIEventArg {
+    waciInvitationId: string;
+    fromDid: string;
+}
+export type IssuerVerificationRuleResult = {
+    verified: boolean;
+    rejectMsg: string;
+};
+export type BusinessRulesVerificationResult = {
+    result: true;
+} | {
+    result: false;
+    rejectMessage: string;
+};
+export type WACICredentialOfferResponse = WACICredentialOfferWaitForResponse | WACICredentialOfferRejected | WACICredentialOfferSucceded;
+export declare enum WACICredentialOfferResult {
+    Succeded = 0,
+    Failed = 1,
+    AsyncProcess = 2
+}
+export declare enum CredentialApplicationResponse {
+    AsyncProcess = 0
+}
+export interface WACICredentialOfferWaitForResponse {
+    result: WACICredentialOfferResult.AsyncProcess;
+}
+export declare class WACICredentialOfferRejected {
+    result: WACICredentialOfferResult.Failed;
+    rejectMsg: string;
+}
+export declare class WACICredentialOfferSucceded {
+    result: WACICredentialOfferResult.Succeded;
+    credentialManifest: {
+        options?: {
+            challenge: string;
+            domain: string;
+        };
+        issuer: {
+            name: string;
+            styles: CredentialManifestStyles;
+        };
+        credentials: {
+            credential: UnsignedCredential;
+            outputDescriptor: OutputDescriptor;
+        }[];
+        inputDescriptors?: InputDescriptor[];
+        frame?: PresentationDefinitionFrame;
+    };
+    constructor(credentialManifest: {
+        options?: {
+            challenge: string;
+            domain: string;
+        };
+        issuer: {
+            name: string;
+            styles: CredentialManifestStyles;
+        };
+        credentials: {
+            credential: UnsignedCredential;
+            outputDescriptor: OutputDescriptor;
+        }[];
+        inputDescriptors?: InputDescriptor[];
+        frame?: PresentationDefinitionFrame;
+    });
+}