@credo-ts/didcomm 0.6.0-alpha-20250128162925

package/build/modules/proofs/protocol/BaseProofProtocol.d.ts

@@ -0,0 +1,97 @@
+import type { ProofProtocol } from './ProofProtocol';
+import type { CreateProofProposalOptions, CreateProofRequestOptions, DeleteProofOptions, GetProofFormatDataReturn, CreateProofProblemReportOptions, ProofProtocolMsgReturnType, AcceptPresentationOptions, AcceptProofProposalOptions, AcceptProofRequestOptions, GetCredentialsForRequestOptions, GetCredentialsForRequestReturn, NegotiateProofProposalOptions, NegotiateProofRequestOptions, SelectCredentialsForRequestOptions, SelectCredentialsForRequestReturn } from './ProofProtocolOptions';
+import type { AgentMessage } from '../../../AgentMessage';
+import type { FeatureRegistry } from '../../../FeatureRegistry';
+import type { MessageHandlerRegistry } from '../../../MessageHandlerRegistry';
+import type { ProblemReportMessage } from '../../../messages';
+import type { InboundMessageContext } from '../../../models';
+import type { ExtractProofFormats, ProofFormatService } from '../formats';
+import type { ProofRole } from '../models';
+import type { ProofExchangeRecord } from '../repository';
+import type { AgentContext, Query, QueryOptions } from '@credo-ts/core';
+import { ProofState } from '../models/ProofState';
+export declare abstract class BaseProofProtocol<PFs extends ProofFormatService[] = ProofFormatService[]> implements ProofProtocol<PFs> {
+    abstract readonly version: string;
+    abstract register(messageHandlerRegistry: MessageHandlerRegistry, featureRegistry: FeatureRegistry): void;
+    abstract createProposal(agentContext: AgentContext, options: CreateProofProposalOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract processProposal(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    abstract acceptProposal(agentContext: AgentContext, options: AcceptProofProposalOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract negotiateProposal(agentContext: AgentContext, options: NegotiateProofProposalOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract createRequest(agentContext: AgentContext, options: CreateProofRequestOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract processRequest(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    abstract acceptRequest(agentContext: AgentContext, options: AcceptProofRequestOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract negotiateRequest(agentContext: AgentContext, options: NegotiateProofRequestOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract getCredentialsForRequest(agentContext: AgentContext, options: GetCredentialsForRequestOptions<PFs>): Promise<GetCredentialsForRequestReturn<PFs>>;
+    abstract selectCredentialsForRequest(agentContext: AgentContext, options: SelectCredentialsForRequestOptions<PFs>): Promise<SelectCredentialsForRequestReturn<PFs>>;
+    abstract processPresentation(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    abstract acceptPresentation(agentContext: AgentContext, options: AcceptPresentationOptions): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    abstract processAck(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    abstract createProblemReport(agentContext: AgentContext, options: CreateProofProblemReportOptions): Promise<ProofProtocolMsgReturnType<ProblemReportMessage>>;
+    abstract findProposalMessage(agentContext: AgentContext, proofExchangeId: string): Promise<AgentMessage | null>;
+    abstract findRequestMessage(agentContext: AgentContext, proofExchangeId: string): Promise<AgentMessage | null>;
+    abstract findPresentationMessage(agentContext: AgentContext, proofExchangeId: string): Promise<AgentMessage | null>;
+    abstract getFormatData(agentContext: AgentContext, proofExchangeId: string): Promise<GetProofFormatDataReturn<ExtractProofFormats<PFs>>>;
+    processProblemReport(messageContext: InboundMessageContext<ProblemReportMessage>): Promise<ProofExchangeRecord>;
+    /**
+     * Update the record to a new state and emit an state changed event. Also updates the record
+     * in storage.
+     *
+     * @param proofRecord The proof record to update the state for
+     * @param newState The state to update to
+     *
+     */
+    updateState(agentContext: AgentContext, proofRecord: ProofExchangeRecord, newState: ProofState): Promise<void>;
+    protected emitStateChangedEvent(agentContext: AgentContext, proofRecord: ProofExchangeRecord, previousState: ProofState | null): void;
+    /**
+     * Retrieve a proof record by id
+     *
+     * @param proofRecordId The proof record id
+     * @throws {RecordNotFoundError} If no record is found
+     * @return The proof record
+     *
+     */
+    getById(agentContext: AgentContext, proofRecordId: string): Promise<ProofExchangeRecord>;
+    /**
+     * Retrieve all proof records
+     *
+     * @returns List containing all proof records
+     */
+    getAll(agentContext: AgentContext): Promise<ProofExchangeRecord[]>;
+    findAllByQuery(agentContext: AgentContext, query: Query<ProofExchangeRecord>, queryOptions?: QueryOptions): Promise<ProofExchangeRecord[]>;
+    /**
+     * Find a proof record by id
+     *
+     * @param proofRecordId the proof record id
+     * @returns The proof record or null if not found
+     */
+    findById(agentContext: AgentContext, proofRecordId: string): Promise<ProofExchangeRecord | null>;
+    delete(agentContext: AgentContext, proofRecord: ProofExchangeRecord, options?: DeleteProofOptions): Promise<void>;
+    /**
+     * Retrieve a proof record by connection id and thread id
+     *
+     * @param properties Properties to query by
+     *
+     * @throws {RecordNotFoundError} If no record is found
+     * @throws {RecordDuplicateError} If multiple records are found
+     *
+     * @returns The proof record
+     */
+    getByProperties(agentContext: AgentContext, properties: {
+        threadId: string;
+        role?: ProofRole;
+        connectionId?: string;
+    }): Promise<ProofExchangeRecord>;
+    /**
+     * Find a proof record by connection id and thread id, returns null if not found
+     *
+     * @param properties Properties to query by
+     *
+     * @returns The proof record
+     */
+    findByProperties(agentContext: AgentContext, properties: {
+        threadId: string;
+        role?: ProofRole;
+        connectionId?: string;
+    }): Promise<ProofExchangeRecord | null>;
+    update(agentContext: AgentContext, proofRecord: ProofExchangeRecord): Promise<void>;
+}

package/build/modules/proofs/protocol/BaseProofProtocol.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProofProtocol = void 0;
+const core_1 = require("@credo-ts/core");
+const repository_1 = require("../../../repository");
+const connections_1 = require("../../connections");
+const ProofEvents_1 = require("../ProofEvents");
+const ProofState_1 = require("../models/ProofState");
+const repository_2 = require("../repository");
+class BaseProofProtocol {
+    async processProblemReport(messageContext) {
+        const { message: proofProblemReportMessage, agentContext, connection } = messageContext;
+        const connectionService = agentContext.dependencyManager.resolve(connections_1.ConnectionService);
+        agentContext.config.logger.debug(`Processing problem report with message id ${proofProblemReportMessage.id}`);
+        const proofRecord = await this.getByProperties(agentContext, {
+            threadId: proofProblemReportMessage.threadId,
+        });
+        // Assert
+        await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+            expectedConnectionId: proofRecord.connectionId,
+        });
+        //  This makes sure that the sender of the incoming message is authorized to do so.
+        if (!proofRecord?.connectionId) {
+            await connectionService.matchIncomingMessageToRequestMessageInOutOfBandExchange(messageContext, {
+                expectedConnectionId: proofRecord?.connectionId,
+            });
+            proofRecord.connectionId = connection?.id;
+        }
+        // Update record
+        proofRecord.errorMessage = `${proofProblemReportMessage.description.code}: ${proofProblemReportMessage.description.en}`;
+        await this.updateState(agentContext, proofRecord, ProofState_1.ProofState.Abandoned);
+        return proofRecord;
+    }
+    /**
+     * Update the record to a new state and emit an state changed event. Also updates the record
+     * in storage.
+     *
+     * @param proofRecord The proof record to update the state for
+     * @param newState The state to update to
+     *
+     */
+    async updateState(agentContext, proofRecord, newState) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        agentContext.config.logger.debug(`Updating proof record ${proofRecord.id} to state ${newState} (previous=${proofRecord.state})`);
+        const previousState = proofRecord.state;
+        proofRecord.state = newState;
+        await proofRepository.update(agentContext, proofRecord);
+        this.emitStateChangedEvent(agentContext, proofRecord, previousState);
+    }
+    emitStateChangedEvent(agentContext, proofRecord, previousState) {
+        const eventEmitter = agentContext.dependencyManager.resolve(core_1.EventEmitter);
+        eventEmitter.emit(agentContext, {
+            type: ProofEvents_1.ProofEventTypes.ProofStateChanged,
+            payload: {
+                proofRecord: proofRecord.clone(),
+                previousState: previousState,
+            },
+        });
+    }
+    /**
+     * Retrieve a proof record by id
+     *
+     * @param proofRecordId The proof record id
+     * @throws {RecordNotFoundError} If no record is found
+     * @return The proof record
+     *
+     */
+    getById(agentContext, proofRecordId) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return proofRepository.getById(agentContext, proofRecordId);
+    }
+    /**
+     * Retrieve all proof records
+     *
+     * @returns List containing all proof records
+     */
+    getAll(agentContext) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return proofRepository.getAll(agentContext);
+    }
+    async findAllByQuery(agentContext, query, queryOptions) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return proofRepository.findByQuery(agentContext, query, queryOptions);
+    }
+    /**
+     * Find a proof record by id
+     *
+     * @param proofRecordId the proof record id
+     * @returns The proof record or null if not found
+     */
+    findById(agentContext, proofRecordId) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return proofRepository.findById(agentContext, proofRecordId);
+    }
+    async delete(agentContext, proofRecord, options) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(repository_1.DidCommMessageRepository);
+        await proofRepository.delete(agentContext, proofRecord);
+        const deleteAssociatedDidCommMessages = options?.deleteAssociatedDidCommMessages ?? true;
+        if (deleteAssociatedDidCommMessages) {
+            const didCommMessages = await didCommMessageRepository.findByQuery(agentContext, {
+                associatedRecordId: proofRecord.id,
+            });
+            for (const didCommMessage of didCommMessages) {
+                await didCommMessageRepository.delete(agentContext, didCommMessage);
+            }
+        }
+    }
+    /**
+     * Retrieve a proof record by connection id and thread id
+     *
+     * @param properties Properties to query by
+     *
+     * @throws {RecordNotFoundError} If no record is found
+     * @throws {RecordDuplicateError} If multiple records are found
+     *
+     * @returns The proof record
+     */
+    getByProperties(agentContext, properties) {
+        const { threadId, connectionId, role } = properties;
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return proofRepository.getSingleByQuery(agentContext, {
+            connectionId,
+            threadId,
+            role,
+        });
+    }
+    /**
+     * Find a proof record by connection id and thread id, returns null if not found
+     *
+     * @param properties Properties to query by
+     *
+     * @returns The proof record
+     */
+    findByProperties(agentContext, properties) {
+        const { role, connectionId, threadId } = properties;
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return proofRepository.findSingleByQuery(agentContext, {
+            connectionId,
+            threadId,
+            role,
+        });
+    }
+    async update(agentContext, proofRecord) {
+        const proofRepository = agentContext.dependencyManager.resolve(repository_2.ProofRepository);
+        return await proofRepository.update(agentContext, proofRecord);
+    }
+}
+exports.BaseProofProtocol = BaseProofProtocol;
+//# sourceMappingURL=BaseProofProtocol.js.map

package/build/modules/proofs/protocol/BaseProofProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseProofProtocol.js","sourceRoot":"","sources":["../../../../src/modules/proofs/protocol/BaseProofProtocol.ts"],"names":[],"mappings":"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"}

package/build/modules/proofs/protocol/ProofProtocol.d.ts

@@ -0,0 +1,51 @@
+import type { CreateProofProposalOptions, CreateProofRequestOptions, DeleteProofOptions, GetProofFormatDataReturn, CreateProofProblemReportOptions, ProofProtocolMsgReturnType, AcceptProofProposalOptions, NegotiateProofProposalOptions, AcceptProofRequestOptions, NegotiateProofRequestOptions, AcceptPresentationOptions, GetCredentialsForRequestOptions, GetCredentialsForRequestReturn, SelectCredentialsForRequestOptions, SelectCredentialsForRequestReturn } from './ProofProtocolOptions';
+import type { AgentMessage } from '../../../AgentMessage';
+import type { FeatureRegistry } from '../../../FeatureRegistry';
+import type { MessageHandlerRegistry } from '../../../MessageHandlerRegistry';
+import type { ProblemReportMessage } from '../../../messages';
+import type { InboundMessageContext } from '../../../models';
+import type { ExtractProofFormats, ProofFormatService } from '../formats';
+import type { ProofRole } from '../models';
+import type { ProofState } from '../models/ProofState';
+import type { ProofExchangeRecord } from '../repository';
+import type { AgentContext, Query, QueryOptions } from '@credo-ts/core';
+export interface ProofProtocol<PFs extends ProofFormatService[] = ProofFormatService[]> {
+    readonly version: string;
+    createProposal(agentContext: AgentContext, options: CreateProofProposalOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    processProposal(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    acceptProposal(agentContext: AgentContext, options: AcceptProofProposalOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    negotiateProposal(agentContext: AgentContext, options: NegotiateProofProposalOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    createRequest(agentContext: AgentContext, options: CreateProofRequestOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    processRequest(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    acceptRequest(agentContext: AgentContext, options: AcceptProofRequestOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    negotiateRequest(agentContext: AgentContext, options: NegotiateProofRequestOptions<PFs>): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    getCredentialsForRequest(agentContext: AgentContext, options: GetCredentialsForRequestOptions<PFs>): Promise<GetCredentialsForRequestReturn<PFs>>;
+    selectCredentialsForRequest(agentContext: AgentContext, options: SelectCredentialsForRequestOptions<PFs>): Promise<SelectCredentialsForRequestReturn<PFs>>;
+    processPresentation(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    acceptPresentation(agentContext: AgentContext, options: AcceptPresentationOptions): Promise<ProofProtocolMsgReturnType<AgentMessage>>;
+    processAck(messageContext: InboundMessageContext<AgentMessage>): Promise<ProofExchangeRecord>;
+    createProblemReport(agentContext: AgentContext, options: CreateProofProblemReportOptions): Promise<ProofProtocolMsgReturnType<ProblemReportMessage>>;
+    processProblemReport(messageContext: InboundMessageContext<ProblemReportMessage>): Promise<ProofExchangeRecord>;
+    findProposalMessage(agentContext: AgentContext, proofExchangeId: string): Promise<AgentMessage | null>;
+    findRequestMessage(agentContext: AgentContext, proofExchangeId: string): Promise<AgentMessage | null>;
+    findPresentationMessage(agentContext: AgentContext, proofExchangeId: string): Promise<AgentMessage | null>;
+    getFormatData(agentContext: AgentContext, proofExchangeId: string): Promise<GetProofFormatDataReturn<ExtractProofFormats<PFs>>>;
+    updateState(agentContext: AgentContext, proofRecord: ProofExchangeRecord, newState: ProofState): Promise<void>;
+    getById(agentContext: AgentContext, proofExchangeId: string): Promise<ProofExchangeRecord>;
+    getAll(agentContext: AgentContext): Promise<ProofExchangeRecord[]>;
+    findAllByQuery(agentContext: AgentContext, query: Query<ProofExchangeRecord>, queryOptions?: QueryOptions): Promise<ProofExchangeRecord[]>;
+    findById(agentContext: AgentContext, proofExchangeId: string): Promise<ProofExchangeRecord | null>;
+    delete(agentContext: AgentContext, proofRecord: ProofExchangeRecord, options?: DeleteProofOptions): Promise<void>;
+    getByProperties(agentContext: AgentContext, properties: {
+        threadId: string;
+        connectionId?: string;
+        role?: ProofRole;
+    }): Promise<ProofExchangeRecord>;
+    findByProperties(agentContext: AgentContext, properties: {
+        threadId: string;
+        connectionId?: string;
+        role?: ProofRole;
+    }): Promise<ProofExchangeRecord | null>;
+    update(agentContext: AgentContext, proofRecord: ProofExchangeRecord): Promise<void>;
+    register(messageHandlerRegistry: MessageHandlerRegistry, featureRegistry: FeatureRegistry): void;
+}

package/build/modules/proofs/protocol/ProofProtocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProofProtocol.js.map

package/build/modules/proofs/protocol/ProofProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofProtocol.js","sourceRoot":"","sources":["../../../../src/modules/proofs/protocol/ProofProtocol.ts"],"names":[],"mappings":""}

package/build/modules/proofs/protocol/ProofProtocolOptions.d.ts

@@ -0,0 +1,128 @@
+import type { ProofProtocol } from './ProofProtocol';
+import type { AgentMessage } from '../../../AgentMessage';
+import type { ConnectionRecord } from '../../connections';
+import type { ExtractProofFormats, ProofFormat, ProofFormatCredentialForRequestPayload, ProofFormatPayload, ProofFormatService } from '../formats';
+import type { AutoAcceptProof } from '../models';
+import type { ProofExchangeRecord } from '../repository';
+/**
+ * Get the format data payload for a specific message from a list of ProofFormat interfaces and a message
+ *
+ * For an indy offer, this resolves to the proof request format as defined here:
+ * https://github.com/hyperledger/aries-rfcs/tree/b3a3942ef052039e73cd23d847f42947f8287da2/features/0592-indy-attachments#proof-request-format
+ *
+ * @example
+ * ```
+ *
+ * type RequestFormatData = ProofFormatDataMessagePayload<[IndyProofFormat, PresentationExchangeProofFormat], 'createRequest'>
+ *
+ * // equal to
+ * type RequestFormatData = {
+ *  indy: {
+ *   // ... payload for indy proof request attachment as defined in RFC 0592 ...
+ *  },
+ *  presentationExchange: {
+ *   // ... payload for presentation exchange request attachment as defined in RFC 0510 ...
+ *  }
+ * }
+ * ```
+ */
+export type ProofFormatDataMessagePayload<CFs extends ProofFormat[] = ProofFormat[], M extends keyof ProofFormat['formatData'] = keyof ProofFormat['formatData']> = {
+    [ProofFormat in CFs[number] as ProofFormat['formatKey']]?: ProofFormat['formatData'][M];
+};
+/**
+ * Infer the {@link ProofFormat} types based on an array of {@link ProofProtocol} types.
+ *
+ * It does this by extracting the `ProofFormatServices` generic from the `ProofProtocol`, and
+ * then extracting the `ProofFormat` generic from each of the `ProofFormatService` types.
+ *
+ * @example
+ * ```
+ * // TheProofFormatServices is now equal to [IndyProofFormatService]
+ * type TheProofFormatServices = ProofFormatsFromProtocols<[V1ProofProtocol]>
+ * ```
+ *
+ * Because the `V1ProofProtocol` is defined as follows:
+ * ```
+ * class V1ProofProtocol implements ProofProtocol<[IndyProofFormatService]> {
+ * }
+ * ```
+ */
+export type ProofFormatsFromProtocols<Type extends ProofProtocol[]> = Type[number] extends ProofProtocol<infer ProofFormatServices> ? ProofFormatServices extends ProofFormatService[] ? ExtractProofFormats<ProofFormatServices> : never : never;
+export type GetProofFormatDataReturn<PFs extends ProofFormat[] = ProofFormat[]> = {
+    proposal?: ProofFormatDataMessagePayload<PFs, 'proposal'>;
+    request?: ProofFormatDataMessagePayload<PFs, 'request'>;
+    presentation?: ProofFormatDataMessagePayload<PFs, 'presentation'>;
+};
+interface BaseOptions {
+    comment?: string;
+    autoAcceptProof?: AutoAcceptProof;
+    /**
+     * Will be ignored for v1 protocol as it is not supported
+     */
+    goalCode?: string;
+    /**
+     * Will be ignored for v1 protocol as it is not supported
+     */
+    goal?: string;
+}
+export interface CreateProofProposalOptions<PFs extends ProofFormatService[]> extends BaseOptions {
+    connectionRecord: ConnectionRecord;
+    proofFormats: ProofFormatPayload<ExtractProofFormats<PFs>, 'createProposal'>;
+    parentThreadId?: string;
+}
+export interface AcceptProofProposalOptions<PFs extends ProofFormatService[]> extends BaseOptions {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatPayload<ExtractProofFormats<PFs>, 'acceptProposal'>;
+    /** @default true */
+    willConfirm?: boolean;
+}
+export interface NegotiateProofProposalOptions<PFs extends ProofFormatService[]> extends BaseOptions {
+    proofRecord: ProofExchangeRecord;
+    proofFormats: ProofFormatPayload<ExtractProofFormats<PFs>, 'createRequest'>;
+    /** @default true */
+    willConfirm?: boolean;
+}
+export interface CreateProofRequestOptions<PFs extends ProofFormatService[]> extends BaseOptions {
+    connectionRecord?: ConnectionRecord;
+    proofFormats: ProofFormatPayload<ExtractProofFormats<PFs>, 'createRequest'>;
+    parentThreadId?: string;
+    /** @default true */
+    willConfirm?: boolean;
+}
+export interface AcceptProofRequestOptions<PFs extends ProofFormatService[]> extends BaseOptions {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatPayload<ExtractProofFormats<PFs>, 'acceptRequest'>;
+}
+export interface NegotiateProofRequestOptions<PFs extends ProofFormatService[]> extends BaseOptions {
+    proofRecord: ProofExchangeRecord;
+    proofFormats: ProofFormatPayload<ExtractProofFormats<PFs>, 'createProposal'>;
+}
+export interface GetCredentialsForRequestOptions<PFs extends ProofFormatService[]> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'getCredentialsForRequest', 'input'>;
+}
+export interface GetCredentialsForRequestReturn<PFs extends ProofFormatService[]> {
+    proofFormats: ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'getCredentialsForRequest', 'output'>;
+}
+export interface SelectCredentialsForRequestOptions<PFs extends ProofFormatService[]> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'selectCredentialsForRequest', 'input'>;
+}
+export interface SelectCredentialsForRequestReturn<PFs extends ProofFormatService[]> {
+    proofFormats: ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'selectCredentialsForRequest', 'output'>;
+}
+export interface AcceptPresentationOptions {
+    proofRecord: ProofExchangeRecord;
+}
+export interface CreateProofProblemReportOptions {
+    proofRecord: ProofExchangeRecord;
+    description: string;
+}
+export interface ProofProtocolMsgReturnType<MessageType extends AgentMessage> {
+    message: MessageType;
+    proofRecord: ProofExchangeRecord;
+}
+export interface DeleteProofOptions {
+    deleteAssociatedDidCommMessages?: boolean;
+}
+export {};

package/build/modules/proofs/protocol/ProofProtocolOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProofProtocolOptions.js.map

package/build/modules/proofs/protocol/ProofProtocolOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofProtocolOptions.js","sourceRoot":"","sources":["../../../../src/modules/proofs/protocol/ProofProtocolOptions.ts"],"names":[],"mappings":""}

package/build/modules/proofs/protocol/index.d.ts

@@ -0,0 +1,5 @@
+export * from './v2';
+import * as ProofProtocolOptions from './ProofProtocolOptions';
+export { ProofProtocol } from './ProofProtocol';
+export { BaseProofProtocol } from './BaseProofProtocol';
+export { ProofProtocolOptions };

package/build/modules/proofs/protocol/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofProtocolOptions = exports.BaseProofProtocol = void 0;
+__exportStar(require("./v2"), exports);
+const ProofProtocolOptions = __importStar(require("./ProofProtocolOptions"));
+exports.ProofProtocolOptions = ProofProtocolOptions;
+// NOTE: ideally we don't export the BaseProofProtocol, but as the V1ProofProtocol is defined in the
+// anoncreds package, we need to export it. We should at some point look at creating a core package which can be used for
+// sharing internal types, and when you want to build you own modules, and an agent package, which is the one you use when
+// consuming the framework
+var BaseProofProtocol_1 = require("./BaseProofProtocol");
+Object.defineProperty(exports, "BaseProofProtocol", { enumerable: true, get: function () { return BaseProofProtocol_1.BaseProofProtocol; } });
+//# sourceMappingURL=index.js.map

package/build/modules/proofs/protocol/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/proofs/protocol/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAoB;AACpB,6EAA8D;AAQrD,oDAAoB;AAL7B,oGAAoG;AACpG,yHAAyH;AACzH,0HAA0H;AAC1H,0BAA0B;AAC1B,yDAAuD;AAA9C,sHAAA,iBAAiB,OAAA"}

package/build/modules/proofs/protocol/v2/ProofFormatCoordinator.d.ts

@@ -0,0 +1,93 @@
+import type { Attachment } from '../../../../decorators/attachment/Attachment';
+import type { ExtractProofFormats, ProofFormatCredentialForRequestPayload, ProofFormatPayload, ProofFormatService } from '../../formats';
+import type { ProofFormatSpec } from '../../models/ProofFormatSpec';
+import type { ProofExchangeRecord } from '../../repository';
+import type { AgentContext } from '@credo-ts/core';
+import { V2PresentationMessage, V2ProposePresentationMessage, V2RequestPresentationMessage } from './messages';
+export declare class ProofFormatCoordinator<PFs extends ProofFormatService[]> {
+    /**
+     * Create a {@link V2ProposePresentationMessage}.
+     *
+     * @param options
+     * @returns The created {@link V2ProposePresentationMessage}
+     *
+     */
+    createProposal(agentContext: AgentContext, { proofFormats, formatServices, proofRecord, comment, goalCode, goal, }: {
+        formatServices: ProofFormatService[];
+        proofFormats: ProofFormatPayload<ExtractProofFormats<PFs>, 'createProposal'>;
+        proofRecord: ProofExchangeRecord;
+        comment?: string;
+        goalCode?: string;
+        goal?: string;
+    }): Promise<V2ProposePresentationMessage>;
+    processProposal(agentContext: AgentContext, { proofRecord, message, formatServices, }: {
+        proofRecord: ProofExchangeRecord;
+        message: V2ProposePresentationMessage;
+        formatServices: ProofFormatService[];
+    }): Promise<void>;
+    acceptProposal(agentContext: AgentContext, { proofRecord, proofFormats, formatServices, comment, goalCode, goal, presentMultiple, willConfirm, }: {
+        proofRecord: ProofExchangeRecord;
+        proofFormats?: ProofFormatPayload<ExtractProofFormats<PFs>, 'acceptProposal'>;
+        formatServices: ProofFormatService[];
+        comment?: string;
+        goalCode?: string;
+        goal?: string;
+        presentMultiple?: boolean;
+        willConfirm?: boolean;
+    }): Promise<V2RequestPresentationMessage>;
+    /**
+     * Create a {@link V2RequestPresentationMessage}.
+     *
+     * @param options
+     * @returns The created {@link V2RequestPresentationMessage}
+     *
+     */
+    createRequest(agentContext: AgentContext, { proofFormats, formatServices, proofRecord, comment, goalCode, goal, presentMultiple, willConfirm, }: {
+        formatServices: ProofFormatService[];
+        proofFormats: ProofFormatPayload<ExtractProofFormats<PFs>, 'createRequest'>;
+        proofRecord: ProofExchangeRecord;
+        comment?: string;
+        goalCode?: string;
+        goal?: string;
+        presentMultiple?: boolean;
+        willConfirm?: boolean;
+    }): Promise<V2RequestPresentationMessage>;
+    processRequest(agentContext: AgentContext, { proofRecord, message, formatServices, }: {
+        proofRecord: ProofExchangeRecord;
+        message: V2RequestPresentationMessage;
+        formatServices: ProofFormatService[];
+    }): Promise<void>;
+    acceptRequest(agentContext: AgentContext, { proofRecord, proofFormats, formatServices, comment, lastPresentation, goalCode, goal, }: {
+        proofRecord: ProofExchangeRecord;
+        proofFormats?: ProofFormatPayload<ExtractProofFormats<PFs>, 'acceptRequest'>;
+        formatServices: ProofFormatService[];
+        comment?: string;
+        lastPresentation?: boolean;
+        goalCode?: string;
+        goal?: string;
+    }): Promise<V2PresentationMessage>;
+    getCredentialsForRequest(agentContext: AgentContext, { proofRecord, proofFormats, formatServices, }: {
+        proofRecord: ProofExchangeRecord;
+        proofFormats?: ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'getCredentialsForRequest', 'input'>;
+        formatServices: ProofFormatService[];
+    }): Promise<ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'getCredentialsForRequest', 'output'>>;
+    selectCredentialsForRequest(agentContext: AgentContext, { proofRecord, proofFormats, formatServices, }: {
+        proofRecord: ProofExchangeRecord;
+        proofFormats?: ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'selectCredentialsForRequest', 'input'>;
+        formatServices: ProofFormatService[];
+    }): Promise<ProofFormatCredentialForRequestPayload<ExtractProofFormats<PFs>, 'selectCredentialsForRequest', 'output'>>;
+    processPresentation(agentContext: AgentContext, { proofRecord, message, requestMessage, formatServices, }: {
+        proofRecord: ProofExchangeRecord;
+        message: V2PresentationMessage;
+        requestMessage: V2RequestPresentationMessage;
+        formatServices: ProofFormatService[];
+    }): Promise<{
+        isValid: true;
+        message: undefined;
+    } | {
+        isValid: false;
+        message: string;
+    }>;
+    getAttachmentForService(credentialFormatService: ProofFormatService, formats: ProofFormatSpec[], attachments: Attachment[]): Attachment;
+    private getAttachmentIdForService;
+}