@credo-ts/anoncreds 0.6.1-pr-2091-20241119140918 → 0.6.2-alpha-20251210145840

package/build/protocols/proofs/v1/DidCommProofV1Protocol.mjs

@@ -0,0 +1,723 @@
+import { AnonCredsHolderServiceSymbol } from "../../../services/AnonCredsHolderService.mjs";
+import "../../../services/index.mjs";
+import { composeProofAutoAccept } from "../../../utils/composeAutoAccept.mjs";
+import { createRequestFromPreview } from "../../../utils/createRequestFromPreview.mjs";
+import "../../../utils/index.mjs";
+import { DidCommPresentationV1AckMessage } from "./messages/DidCommPresentationV1AckMessage.mjs";
+import { DidCommPresentationV1Message, INDY_PROOF_ATTACHMENT_ID } from "./messages/DidCommPresentationV1Message.mjs";
+import { DidCommPresentationV1ProblemReportMessage } from "./messages/DidCommPresentationV1ProblemReportMessage.mjs";
+import { DidCommPresentationV1Preview } from "./models/DidCommPresentationV1Preview.mjs";
+import { DidCommProposePresentationV1Message } from "./messages/DidCommProposePresentationV1Message.mjs";
+import { DidCommRequestPresentationV1Message, INDY_PROOF_REQUEST_ATTACHMENT_ID } from "./messages/DidCommRequestPresentationV1Message.mjs";
+import "./messages/index.mjs";
+import { DidCommPresentationV1ProblemReportError } from "./errors/DidCommPresentationV1ProblemReportError.mjs";
+import "./errors/index.mjs";
+import { DidCommPresentationV1AckHandler } from "./handlers/DidCommPresentationV1AckHandler.mjs";
+import { DidCommPresentationV1Handler } from "./handlers/DidCommPresentationV1Handler.mjs";
+import { DidCommPresentationV1ProblemReportHandler } from "./handlers/DidCommPresentationV1ProblemReportHandler.mjs";
+import { DidCommProposePresentationV1Handler } from "./handlers/DidCommProposePresentationV1Handler.mjs";
+import { DidCommRequestPresentationV1Handler } from "./handlers/DidCommRequestPresentationV1Handler.mjs";
+import "./handlers/index.mjs";
+import { CredoError, JsonEncoder, JsonTransformer, MessageValidator, utils } from "@credo-ts/core";
+import { AckStatus, DidCommAttachment, DidCommAutoAcceptProof, DidCommBaseProofProtocol, DidCommConnectionService, DidCommMessageRepository, DidCommMessageRole, DidCommPresentationProblemReportReason, DidCommProofExchangeRecord, DidCommProofExchangeRepository, DidCommProofRole, DidCommProofState, DidCommProofsModuleConfig, DidCommProtocol } from "@credo-ts/didcomm";
+
+//#region src/protocols/proofs/v1/DidCommProofV1Protocol.ts
+var DidCommProofV1Protocol = class extends DidCommBaseProofProtocol {
+	constructor({ indyProofFormat }) {
+		super();
+		this.version = "v1";
+		this.indyProofFormat = indyProofFormat;
+	}
+	/**
+	* Registers the protocol implementation (handlers, feature registry) on the agent.
+	*/
+	register(messageHandlerRegistry, featureRegistry) {
+		messageHandlerRegistry.registerMessageHandlers([
+			new DidCommProposePresentationV1Handler(this),
+			new DidCommRequestPresentationV1Handler(this),
+			new DidCommPresentationV1Handler(this),
+			new DidCommPresentationV1AckHandler(this),
+			new DidCommPresentationV1ProblemReportHandler(this)
+		]);
+		featureRegistry.register(new DidCommProtocol({
+			id: "https://didcomm.org/present-proof/1.0",
+			roles: ["prover", "verifier"]
+		}));
+	}
+	async createProposal(agentContext, { proofFormats, connectionRecord, comment, parentThreadId, autoAcceptProof }) {
+		this.assertOnlyIndyFormat(proofFormats);
+		const proofRepository = agentContext.dependencyManager.resolve(DidCommProofExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		if (!proofFormats.indy) throw new CredoError("Missing indy proof format in v1 create proposal call.");
+		const presentationProposal = new DidCommPresentationV1Preview({
+			attributes: proofFormats.indy?.attributes,
+			predicates: proofFormats.indy?.predicates
+		});
+		MessageValidator.validateSync(presentationProposal);
+		const message = new DidCommProposePresentationV1Message({
+			presentationProposal,
+			comment
+		});
+		if (parentThreadId) message.setThread({ parentThreadId });
+		const proofRecord = new DidCommProofExchangeRecord({
+			connectionId: connectionRecord?.id,
+			threadId: message.threadId,
+			parentThreadId: message.thread?.parentThreadId,
+			state: DidCommProofState.ProposalSent,
+			role: DidCommProofRole.Prover,
+			autoAcceptProof,
+			protocolVersion: "v1"
+		});
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			agentMessage: message,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		await proofRepository.save(agentContext, proofRecord);
+		this.emitStateChangedEvent(agentContext, proofRecord, null);
+		return {
+			proofRecord,
+			message
+		};
+	}
+	async processProposal(messageContext) {
+		const { message: proposalMessage, connection, agentContext } = messageContext;
+		const proofRepository = agentContext.dependencyManager.resolve(DidCommProofExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		agentContext.config.logger.debug(`Processing presentation proposal with message id ${proposalMessage.id}`);
+		let proofRecord = await this.findByProperties(agentContext, {
+			threadId: proposalMessage.threadId,
+			role: DidCommProofRole.Verifier,
+			connectionId: connection?.id
+		});
+		if (proofRecord) {
+			agentContext.config.logger.debug("Proof record already exists for incoming proposal");
+			proofRecord.assertState(DidCommProofState.RequestSent);
+			proofRecord.assertProtocolVersion("v1");
+			const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
+				associatedRecordId: proofRecord.id,
+				messageClass: DidCommProposePresentationV1Message,
+				role: DidCommMessageRole.Receiver
+			});
+			const lastSentMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+				associatedRecordId: proofRecord.id,
+				messageClass: DidCommRequestPresentationV1Message,
+				role: DidCommMessageRole.Sender
+			});
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+				lastReceivedMessage,
+				lastSentMessage,
+				expectedConnectionId: proofRecord.connectionId
+			});
+			await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+				agentMessage: proposalMessage,
+				associatedRecordId: proofRecord.id,
+				role: DidCommMessageRole.Receiver
+			});
+			await this.updateState(agentContext, proofRecord, DidCommProofState.ProposalReceived);
+		} else {
+			agentContext.config.logger.debug("Proof record does not exist yet for incoming proposal");
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
+			proofRecord = new DidCommProofExchangeRecord({
+				connectionId: connection?.id,
+				threadId: proposalMessage.threadId,
+				parentThreadId: proposalMessage.thread?.parentThreadId,
+				state: DidCommProofState.ProposalReceived,
+				role: DidCommProofRole.Verifier,
+				protocolVersion: "v1"
+			});
+			await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+				agentMessage: proposalMessage,
+				associatedRecordId: proofRecord.id,
+				role: DidCommMessageRole.Receiver
+			});
+			await proofRepository.save(agentContext, proofRecord);
+			this.emitStateChangedEvent(agentContext, proofRecord, null);
+		}
+		return proofRecord;
+	}
+	async acceptProposal(agentContext, { proofRecord, proofFormats, comment, autoAcceptProof }) {
+		proofRecord.assertProtocolVersion("v1");
+		proofRecord.assertState(DidCommProofState.ProposalReceived);
+		if (proofFormats) this.assertOnlyIndyFormat(proofFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const proposalMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommProposePresentationV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const indyFormat = proofFormats?.indy;
+		const anonCredsHolderService = agentContext.resolve(AnonCredsHolderServiceSymbol);
+		const requestFromPreview = createRequestFromPreview({
+			attributes: proposalMessage.presentationProposal.attributes,
+			predicates: proposalMessage.presentationProposal.predicates,
+			name: indyFormat?.name ?? "Proof Request",
+			version: indyFormat?.version ?? "1.0",
+			nonce: anonCredsHolderService.generateNonce(agentContext)
+		});
+		const proposalAttachment = new DidCommAttachment({ data: { json: JsonTransformer.toJSON(requestFromPreview) } });
+		const { attachment } = await this.indyProofFormat.acceptProposal(agentContext, {
+			attachmentId: INDY_PROOF_REQUEST_ATTACHMENT_ID,
+			proofRecord,
+			proposalAttachment
+		});
+		const requestPresentationMessage = new DidCommRequestPresentationV1Message({
+			comment,
+			requestAttachments: [attachment]
+		});
+		requestPresentationMessage.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: requestPresentationMessage,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+		await this.updateState(agentContext, proofRecord, DidCommProofState.RequestSent);
+		return {
+			message: requestPresentationMessage,
+			proofRecord
+		};
+	}
+	async negotiateProposal(agentContext, { proofFormats, proofRecord, comment, autoAcceptProof }) {
+		proofRecord.assertProtocolVersion("v1");
+		proofRecord.assertState(DidCommProofState.ProposalReceived);
+		this.assertOnlyIndyFormat(proofFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const { attachment } = await this.indyProofFormat.createRequest(agentContext, {
+			attachmentId: INDY_PROOF_REQUEST_ATTACHMENT_ID,
+			proofFormats,
+			proofRecord
+		});
+		const requestPresentationMessage = new DidCommRequestPresentationV1Message({
+			comment,
+			requestAttachments: [attachment]
+		});
+		requestPresentationMessage.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: requestPresentationMessage,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+		await this.updateState(agentContext, proofRecord, DidCommProofState.RequestSent);
+		return {
+			message: requestPresentationMessage,
+			proofRecord
+		};
+	}
+	async createRequest(agentContext, { proofFormats, connectionRecord, comment, parentThreadId, autoAcceptProof }) {
+		this.assertOnlyIndyFormat(proofFormats);
+		const proofRepository = agentContext.dependencyManager.resolve(DidCommProofExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		if (!proofFormats.indy) throw new CredoError("Missing indy proof request data for v1 create request");
+		const proofRecord = new DidCommProofExchangeRecord({
+			connectionId: connectionRecord?.id,
+			threadId: utils.uuid(),
+			parentThreadId,
+			state: DidCommProofState.RequestSent,
+			role: DidCommProofRole.Verifier,
+			autoAcceptProof,
+			protocolVersion: "v1"
+		});
+		const { attachment } = await this.indyProofFormat.createRequest(agentContext, {
+			attachmentId: INDY_PROOF_REQUEST_ATTACHMENT_ID,
+			proofFormats,
+			proofRecord
+		});
+		const message = new DidCommRequestPresentationV1Message({
+			id: proofRecord.threadId,
+			comment,
+			requestAttachments: [attachment]
+		});
+		message.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			agentMessage: message,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		await proofRepository.save(agentContext, proofRecord);
+		this.emitStateChangedEvent(agentContext, proofRecord, null);
+		return {
+			message,
+			proofRecord
+		};
+	}
+	async processRequest(messageContext) {
+		const { message: proofRequestMessage, connection, agentContext } = messageContext;
+		const proofRepository = agentContext.dependencyManager.resolve(DidCommProofExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		agentContext.config.logger.debug(`Processing presentation request with id ${proofRequestMessage.id}`);
+		let proofRecord = await this.findByProperties(agentContext, {
+			threadId: proofRequestMessage.threadId,
+			role: DidCommProofRole.Prover
+		});
+		const requestAttachment = proofRequestMessage.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) throw new CredoError(`Indy attachment with id ${INDY_PROOF_REQUEST_ATTACHMENT_ID} not found in request message`);
+		if (proofRecord) {
+			const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
+				associatedRecordId: proofRecord.id,
+				messageClass: DidCommRequestPresentationV1Message,
+				role: DidCommMessageRole.Receiver
+			});
+			const lastSentMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+				associatedRecordId: proofRecord.id,
+				messageClass: DidCommProposePresentationV1Message,
+				role: DidCommMessageRole.Sender
+			});
+			proofRecord.assertProtocolVersion("v1");
+			proofRecord.assertState(DidCommProofState.ProposalSent);
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+				lastReceivedMessage,
+				lastSentMessage,
+				expectedConnectionId: proofRecord.connectionId
+			});
+			if (!proofRecord.connectionId) proofRecord.connectionId = connection?.id;
+			await this.indyProofFormat.processRequest(agentContext, {
+				attachment: requestAttachment,
+				proofRecord
+			});
+			await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+				agentMessage: proofRequestMessage,
+				associatedRecordId: proofRecord.id,
+				role: DidCommMessageRole.Receiver
+			});
+			await this.updateState(agentContext, proofRecord, DidCommProofState.RequestReceived);
+		} else {
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
+			proofRecord = new DidCommProofExchangeRecord({
+				connectionId: connection?.id,
+				threadId: proofRequestMessage.threadId,
+				parentThreadId: proofRequestMessage.thread?.parentThreadId,
+				state: DidCommProofState.RequestReceived,
+				role: DidCommProofRole.Prover,
+				protocolVersion: "v1"
+			});
+			await this.indyProofFormat.processRequest(agentContext, {
+				attachment: requestAttachment,
+				proofRecord
+			});
+			await didCommMessageRepository.saveAgentMessage(agentContext, {
+				agentMessage: proofRequestMessage,
+				associatedRecordId: proofRecord.id,
+				role: DidCommMessageRole.Receiver
+			});
+			await proofRepository.save(agentContext, proofRecord);
+			this.emitStateChangedEvent(agentContext, proofRecord, null);
+		}
+		return proofRecord;
+	}
+	async negotiateRequest(agentContext, { proofFormats, proofRecord, comment, autoAcceptProof }) {
+		proofRecord.assertProtocolVersion("v1");
+		proofRecord.assertState(DidCommProofState.RequestReceived);
+		this.assertOnlyIndyFormat(proofFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		if (!proofRecord.connectionId) throw new CredoError(`No connectionId found for proof record '${proofRecord.id}'. Connection-less verification does not support negotiation.`);
+		if (!proofFormats.indy) throw new CredoError("Missing indy proof format in v1 negotiate request call.");
+		const presentationProposal = new DidCommPresentationV1Preview({
+			attributes: proofFormats.indy?.attributes,
+			predicates: proofFormats.indy?.predicates
+		});
+		MessageValidator.validateSync(presentationProposal);
+		const message = new DidCommProposePresentationV1Message({
+			comment,
+			presentationProposal
+		});
+		message.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: message,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+		await this.updateState(agentContext, proofRecord, DidCommProofState.ProposalSent);
+		return {
+			proofRecord,
+			message
+		};
+	}
+	async acceptRequest(agentContext, { proofRecord, proofFormats, autoAcceptProof, comment }) {
+		proofRecord.assertProtocolVersion("v1");
+		proofRecord.assertState(DidCommProofState.RequestReceived);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommRequestPresentationV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommProposePresentationV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		const indyProofRequest = requestMessage.indyProofRequest;
+		if (!requestAttachment || !indyProofRequest) throw new DidCommPresentationV1ProblemReportError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`, { problemCode: DidCommPresentationProblemReportReason.Abandoned });
+		const proposalAttachment = proposalMessage ? new DidCommAttachment({ data: { json: JsonTransformer.toJSON(createRequestFromPreview({
+			attributes: proposalMessage.presentationProposal?.attributes,
+			predicates: proposalMessage.presentationProposal?.predicates,
+			name: indyProofRequest.name,
+			nonce: indyProofRequest.nonce,
+			version: indyProofRequest.nonce
+		})) } }) : void 0;
+		const { attachment } = await this.indyProofFormat.acceptRequest(agentContext, {
+			attachmentId: INDY_PROOF_ATTACHMENT_ID,
+			requestAttachment,
+			proposalAttachment,
+			proofFormats,
+			proofRecord
+		});
+		const message = new DidCommPresentationV1Message({
+			comment,
+			presentationAttachments: [attachment]
+		});
+		message.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			agentMessage: message,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+		await this.updateState(agentContext, proofRecord, DidCommProofState.PresentationSent);
+		return {
+			message,
+			proofRecord
+		};
+	}
+	async getCredentialsForRequest(agentContext, { proofRecord, proofFormats }) {
+		if (proofFormats) this.assertOnlyIndyFormat(proofFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommRequestPresentationV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommProposePresentationV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		const indyProofRequest = requestMessage.indyProofRequest;
+		if (!requestAttachment || !indyProofRequest) throw new CredoError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`);
+		const proposalAttachment = proposalMessage ? new DidCommAttachment({ data: { json: JsonTransformer.toJSON(createRequestFromPreview({
+			attributes: proposalMessage.presentationProposal?.attributes,
+			predicates: proposalMessage.presentationProposal?.predicates,
+			name: indyProofRequest.name,
+			nonce: indyProofRequest.nonce,
+			version: indyProofRequest.nonce
+		})) } }) : void 0;
+		return { proofFormats: { indy: await this.indyProofFormat.getCredentialsForRequest(agentContext, {
+			proofRecord,
+			requestAttachment,
+			proofFormats,
+			proposalAttachment
+		}) } };
+	}
+	async selectCredentialsForRequest(agentContext, { proofRecord, proofFormats }) {
+		if (proofFormats) this.assertOnlyIndyFormat(proofFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommRequestPresentationV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommProposePresentationV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		const indyProofRequest = requestMessage.indyProofRequest;
+		if (!requestAttachment || !indyProofRequest) throw new CredoError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`);
+		const proposalAttachment = proposalMessage ? new DidCommAttachment({ data: { json: JsonTransformer.toJSON(createRequestFromPreview({
+			attributes: proposalMessage.presentationProposal?.attributes,
+			predicates: proposalMessage.presentationProposal?.predicates,
+			name: indyProofRequest.name,
+			nonce: indyProofRequest.nonce,
+			version: indyProofRequest.nonce
+		})) } }) : void 0;
+		return { proofFormats: { indy: await this.indyProofFormat.selectCredentialsForRequest(agentContext, {
+			proofFormats,
+			proofRecord,
+			requestAttachment,
+			proposalAttachment
+		}) } };
+	}
+	async processPresentation(messageContext) {
+		const { message: presentationMessage, connection, agentContext } = messageContext;
+		agentContext.config.logger.debug(`Processing presentation with message id ${presentationMessage.id}`);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		const proofRecord = await this.getByProperties(agentContext, {
+			threadId: presentationMessage.threadId,
+			role: DidCommProofRole.Verifier
+		});
+		const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommProposePresentationV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommRequestPresentationV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		proofRecord.assertState(DidCommProofState.RequestSent);
+		proofRecord.assertProtocolVersion("v1");
+		await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+			lastReceivedMessage: proposalMessage,
+			lastSentMessage: requestMessage,
+			expectedConnectionId: proofRecord.connectionId
+		});
+		if (!proofRecord.connectionId) {
+			await connectionService.matchIncomingMessageToRequestMessageInOutOfBandExchange(messageContext, { expectedConnectionId: proofRecord.connectionId });
+			proofRecord.connectionId = connection?.id;
+		}
+		const presentationAttachment = presentationMessage.getPresentationAttachmentById(INDY_PROOF_ATTACHMENT_ID);
+		if (!presentationAttachment) {
+			proofRecord.errorMessage = "Missing indy proof attachment";
+			await this.updateState(agentContext, proofRecord, DidCommProofState.Abandoned);
+			throw new DidCommPresentationV1ProblemReportError(proofRecord.errorMessage, { problemCode: DidCommPresentationProblemReportReason.Abandoned });
+		}
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) {
+			proofRecord.errorMessage = "Missing indy proof request attachment";
+			await this.updateState(agentContext, proofRecord, DidCommProofState.Abandoned);
+			throw new DidCommPresentationV1ProblemReportError(proofRecord.errorMessage, { problemCode: DidCommPresentationProblemReportReason.Abandoned });
+		}
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			agentMessage: presentationMessage,
+			associatedRecordId: proofRecord.id,
+			role: DidCommMessageRole.Receiver
+		});
+		let isValid;
+		try {
+			isValid = await this.indyProofFormat.processPresentation(agentContext, {
+				proofRecord,
+				attachment: presentationAttachment,
+				requestAttachment
+			});
+		} catch (error) {
+			proofRecord.errorMessage = error.message ?? "Error verifying proof on presentation";
+			proofRecord.isVerified = false;
+			await this.updateState(agentContext, proofRecord, DidCommProofState.Abandoned);
+			throw new DidCommPresentationV1ProblemReportError("Error verifying proof on presentation", { problemCode: DidCommPresentationProblemReportReason.Abandoned });
+		}
+		if (!isValid) {
+			proofRecord.errorMessage = "Invalid proof";
+			proofRecord.isVerified = false;
+			await this.updateState(agentContext, proofRecord, DidCommProofState.Abandoned);
+			throw new DidCommPresentationV1ProblemReportError("Invalid proof", { problemCode: DidCommPresentationProblemReportReason.Abandoned });
+		}
+		proofRecord.isVerified = isValid;
+		await this.updateState(agentContext, proofRecord, DidCommProofState.PresentationReceived);
+		return proofRecord;
+	}
+	async acceptPresentation(agentContext, { proofRecord }) {
+		agentContext.config.logger.debug(`Creating presentation ack for proof record with id ${proofRecord.id}`);
+		proofRecord.assertProtocolVersion("v1");
+		proofRecord.assertState(DidCommProofState.PresentationReceived);
+		const ackMessage = new DidCommPresentationV1AckMessage({
+			status: AckStatus.OK,
+			threadId: proofRecord.threadId
+		});
+		ackMessage.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		await this.updateState(agentContext, proofRecord, DidCommProofState.Done);
+		return {
+			message: ackMessage,
+			proofRecord
+		};
+	}
+	async processAck(messageContext) {
+		const { message: presentationAckMessage, connection, agentContext } = messageContext;
+		agentContext.config.logger.debug(`Processing presentation ack with message id ${presentationAckMessage.id}`);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		const proofRecord = await this.getByProperties(agentContext, {
+			threadId: presentationAckMessage.threadId,
+			role: DidCommProofRole.Prover,
+			connectionId: connection?.id
+		});
+		const lastReceivedMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommRequestPresentationV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const lastSentMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: proofRecord.id,
+			messageClass: DidCommPresentationV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		proofRecord.assertProtocolVersion("v1");
+		proofRecord.assertState(DidCommProofState.PresentationSent);
+		await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+			lastReceivedMessage,
+			lastSentMessage,
+			expectedConnectionId: proofRecord.connectionId
+		});
+		await this.updateState(agentContext, proofRecord, DidCommProofState.Done);
+		return proofRecord;
+	}
+	async createProblemReport(_agentContext, { proofRecord, description }) {
+		const message = new DidCommPresentationV1ProblemReportMessage({ description: {
+			code: DidCommPresentationProblemReportReason.Abandoned,
+			en: description
+		} });
+		message.setThread({
+			threadId: proofRecord.threadId,
+			parentThreadId: proofRecord.parentThreadId
+		});
+		return {
+			proofRecord,
+			message
+		};
+	}
+	async shouldAutoRespondToProposal(agentContext, options) {
+		const { proofRecord, proposalMessage } = options;
+		const proofsModuleConfig = agentContext.dependencyManager.resolve(DidCommProofsModuleConfig);
+		const autoAccept = composeProofAutoAccept(proofRecord.autoAcceptProof, proofsModuleConfig.autoAcceptProofs);
+		if (autoAccept === DidCommAutoAcceptProof.Always) return true;
+		if (autoAccept === DidCommAutoAcceptProof.Never) return false;
+		const requestAttachment = (await this.findRequestMessage(agentContext, proofRecord.id))?.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) return false;
+		const anonCredsHolderService = agentContext.resolve(AnonCredsHolderServiceSymbol);
+		const rfc0592Proposal = JsonTransformer.toJSON(createRequestFromPreview({
+			name: "Proof Request",
+			nonce: anonCredsHolderService.generateNonce(agentContext),
+			version: "1.0",
+			attributes: proposalMessage.presentationProposal.attributes,
+			predicates: proposalMessage.presentationProposal.predicates
+		}));
+		return this.indyProofFormat.shouldAutoRespondToProposal(agentContext, {
+			proofRecord,
+			proposalAttachment: new DidCommAttachment({ data: { json: rfc0592Proposal } }),
+			requestAttachment
+		});
+	}
+	async shouldAutoRespondToRequest(agentContext, options) {
+		const { proofRecord, requestMessage } = options;
+		const proofsModuleConfig = agentContext.dependencyManager.resolve(DidCommProofsModuleConfig);
+		const autoAccept = composeProofAutoAccept(proofRecord.autoAcceptProof, proofsModuleConfig.autoAcceptProofs);
+		if (autoAccept === DidCommAutoAcceptProof.Always) return true;
+		if (autoAccept === DidCommAutoAcceptProof.Never) return false;
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) return false;
+		const proposalMessage = await this.findProposalMessage(agentContext, proofRecord.id);
+		if (!proposalMessage) return false;
+		const rfc0592Proposal = createRequestFromPreview({
+			name: "Proof Request",
+			nonce: agentContext.resolve(AnonCredsHolderServiceSymbol).generateNonce(agentContext),
+			version: "1.0",
+			attributes: proposalMessage.presentationProposal.attributes,
+			predicates: proposalMessage.presentationProposal.predicates
+		});
+		return this.indyProofFormat.shouldAutoRespondToRequest(agentContext, {
+			proofRecord,
+			proposalAttachment: new DidCommAttachment({ data: { base64: JsonEncoder.toBase64(rfc0592Proposal) } }),
+			requestAttachment
+		});
+	}
+	async shouldAutoRespondToPresentation(agentContext, options) {
+		const { proofRecord, presentationMessage } = options;
+		const proofsModuleConfig = agentContext.dependencyManager.resolve(DidCommProofsModuleConfig);
+		const autoAccept = composeProofAutoAccept(proofRecord.autoAcceptProof, proofsModuleConfig.autoAcceptProofs);
+		if (autoAccept === DidCommAutoAcceptProof.Always) return true;
+		if (autoAccept === DidCommAutoAcceptProof.Never) return false;
+		const presentationAttachment = presentationMessage.getPresentationAttachmentById(INDY_PROOF_ATTACHMENT_ID);
+		if (!presentationAttachment) return false;
+		const requestAttachment = (await this.findRequestMessage(agentContext, proofRecord.id))?.getRequestAttachmentById(INDY_PROOF_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) return false;
+		const proposalMessage = await this.findProposalMessage(agentContext, proofRecord.id);
+		const anonCredsHolderService = agentContext.resolve(AnonCredsHolderServiceSymbol);
+		const rfc0592Proposal = proposalMessage ? JsonTransformer.toJSON(createRequestFromPreview({
+			name: "Proof Request",
+			nonce: await anonCredsHolderService.generateNonce(agentContext),
+			version: "1.0",
+			attributes: proposalMessage.presentationProposal.attributes,
+			predicates: proposalMessage.presentationProposal.predicates
+		})) : void 0;
+		return this.indyProofFormat.shouldAutoRespondToPresentation(agentContext, {
+			proofRecord,
+			requestAttachment,
+			presentationAttachment,
+			proposalAttachment: new DidCommAttachment({ data: { json: rfc0592Proposal } })
+		});
+	}
+	async findProposalMessage(agentContext, proofExchangeRecordId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: proofExchangeRecordId,
+			messageClass: DidCommProposePresentationV1Message
+		});
+	}
+	async findRequestMessage(agentContext, proofExchangeRecordId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: proofExchangeRecordId,
+			messageClass: DidCommRequestPresentationV1Message
+		});
+	}
+	async findPresentationMessage(agentContext, proofExchangeRecordId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: proofExchangeRecordId,
+			messageClass: DidCommPresentationV1Message
+		});
+	}
+	async getFormatData(agentContext, proofExchangeRecordId) {
+		const anonCredsHolderService = agentContext.resolve(AnonCredsHolderServiceSymbol);
+		const [proposalMessage, requestMessage, presentationMessage] = await Promise.all([
+			this.findProposalMessage(agentContext, proofExchangeRecordId),
+			this.findRequestMessage(agentContext, proofExchangeRecordId),
+			this.findPresentationMessage(agentContext, proofExchangeRecordId)
+		]);
+		let indyProposeProof;
+		const indyRequestProof = requestMessage?.indyProofRequest ?? void 0;
+		const indyPresentProof = presentationMessage?.indyProof ?? void 0;
+		if (proposalMessage && indyRequestProof) indyProposeProof = createRequestFromPreview({
+			name: indyRequestProof.name,
+			version: indyRequestProof.version,
+			nonce: indyRequestProof.nonce,
+			attributes: proposalMessage.presentationProposal.attributes,
+			predicates: proposalMessage.presentationProposal.predicates
+		});
+		else if (proposalMessage) indyProposeProof = createRequestFromPreview({
+			name: "Proof Request",
+			version: "1.0",
+			nonce: anonCredsHolderService.generateNonce(agentContext),
+			attributes: proposalMessage.presentationProposal.attributes,
+			predicates: proposalMessage.presentationProposal.predicates
+		});
+		return {
+			proposal: proposalMessage ? { indy: indyProposeProof } : void 0,
+			request: requestMessage ? { indy: indyRequestProof } : void 0,
+			presentation: presentationMessage ? { indy: indyPresentProof } : void 0
+		};
+	}
+	assertOnlyIndyFormat(proofFormats) {
+		const formatKeys = Object.keys(proofFormats);
+		if (formatKeys.length === 0) return;
+		if (formatKeys.length !== 1 || !formatKeys.includes("indy")) throw new CredoError("Only indy proof format is supported for present proof v1 protocol");
+	}
+};
+
+//#endregion
+export { DidCommProofV1Protocol };
+//# sourceMappingURL=DidCommProofV1Protocol.mjs.map