@credo-ts/anoncreds 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/protocols/credentials/v1/DidCommCredentialV1Protocol.mjs

@@ -0,0 +1,827 @@
+import { composeCredentialAutoAccept } from "../../../utils/composeAutoAccept.mjs";
+import { areCredentialPreviewAttributesEqual } from "../../../utils/credentialPreviewAttributes.mjs";
+import "../../../utils/index.mjs";
+import { AnonCredsCredentialProposal } from "../../../models/AnonCredsCredentialProposal.mjs";
+import { DidCommCredentialV1AckMessage } from "./messages/DidCommCredentialV1AckMessage.mjs";
+import { DidCommCredentialV1Preview } from "./messages/DidCommCredentialV1Preview.mjs";
+import { DidCommCredentialV1ProblemReportMessage } from "./messages/DidCommCredentialV1ProblemReportMessage.mjs";
+import { DidCommIssueCredentialV1Message, INDY_CREDENTIAL_ATTACHMENT_ID } from "./messages/DidCommIssueCredentialV1Message.mjs";
+import { INDY_CREDENTIAL_OFFER_ATTACHMENT_ID, V1OfferCredentialMessage } from "./messages/DidCommOfferCredentialV1Message.mjs";
+import { DidCommProposeCredentialV1Message } from "./messages/DidCommProposeCredentialV1Message.mjs";
+import { DidCommRequestCredentialV1Message, INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID } from "./messages/DidCommRequestCredentialV1Message.mjs";
+import "./messages/index.mjs";
+import { DidCommCredentialV1AckHandler } from "./handlers/DidCommCredentialV1AckHandler.mjs";
+import { DidCommCredentialV1ProblemReportHandler } from "./handlers/DidCommCredentialV1ProblemReportHandler.mjs";
+import { DidCommIssueCredentialV1Handler } from "./handlers/DidCommIssueCredentialV1Handler.mjs";
+import { DidCommOfferCredentialV1Handler } from "./handlers/DidCommOfferCredentialV1Handler.mjs";
+import { DidCommProposeCredentialV1Handler } from "./handlers/DidCommProposeCredentialV1Handler.mjs";
+import { DidCommRequestCredentialV1Handler } from "./handlers/DidCommRequestCredentialV1Handler.mjs";
+import "./handlers/index.mjs";
+import { CredoError, JsonTransformer, utils } from "@credo-ts/core";
+import { AckStatus, BaseDidCommCredentialProtocol, DidCommAttachment, DidCommAttachmentData, DidCommAutoAcceptCredential, DidCommConnectionService, DidCommCredentialExchangeRecord, DidCommCredentialExchangeRepository, DidCommCredentialProblemReportReason, DidCommCredentialRole, DidCommCredentialState, DidCommCredentialsModuleConfig, DidCommMessageRepository, DidCommMessageRole, DidCommProtocol } from "@credo-ts/didcomm";
+
+//#region src/protocols/credentials/v1/DidCommCredentialV1Protocol.ts
+var DidCommCredentialV1Protocol = class extends BaseDidCommCredentialProtocol {
+	constructor({ indyCredentialFormat }) {
+		super();
+		this.version = "v1";
+		this.indyCredentialFormat = indyCredentialFormat;
+	}
+	/**
+	* Registers the protocol implementation (handlers, feature registry) on the agent.
+	*/
+	register(messageHandlerRegistry, featureRegistry) {
+		messageHandlerRegistry.registerMessageHandlers([
+			new DidCommProposeCredentialV1Handler(this),
+			new DidCommOfferCredentialV1Handler(this),
+			new DidCommRequestCredentialV1Handler(this),
+			new DidCommIssueCredentialV1Handler(this),
+			new DidCommCredentialV1AckHandler(this),
+			new DidCommCredentialV1ProblemReportHandler(this)
+		]);
+		featureRegistry.register(new DidCommProtocol({
+			id: "https://didcomm.org/issue-credential/1.0",
+			roles: ["holder", "issuer"]
+		}));
+	}
+	/**
+	* Create a {@link ProposeCredentialMessage} not bound to an existing credential exchange.
+	* To create a proposal as response to an existing credential exchange, use {@link createProposalAsResponse}.
+	*
+	* @param options The object containing config options
+	* @returns Object containing proposal message and associated credential record
+	*
+	*/
+	async createProposal(agentContext, { connectionRecord, credentialFormats, comment, autoAcceptCredential }) {
+		this.assertOnlyIndyFormat(credentialFormats);
+		const credentialRepository = agentContext.dependencyManager.resolve(DidCommCredentialExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		if (!credentialFormats.indy) throw new CredoError("Missing indy credential format in v1 create proposal call.");
+		const credentialExchangeRecord = new DidCommCredentialExchangeRecord({
+			connectionId: connectionRecord.id,
+			threadId: utils.uuid(),
+			state: DidCommCredentialState.ProposalSent,
+			role: DidCommCredentialRole.Holder,
+			autoAcceptCredential,
+			protocolVersion: "v1"
+		});
+		const { previewAttributes, attachment } = await this.indyCredentialFormat.createProposal(agentContext, {
+			credentialFormats,
+			credentialExchangeRecord
+		});
+		const indyCredentialProposal = JsonTransformer.fromJSON(attachment.getDataAsJson(), AnonCredsCredentialProposal);
+		const credentialProposal = previewAttributes ? new DidCommCredentialV1Preview({ attributes: previewAttributes }) : void 0;
+		const message = new DidCommProposeCredentialV1Message({
+			...indyCredentialProposal,
+			id: credentialExchangeRecord.threadId,
+			credentialPreview: credentialProposal,
+			comment
+		});
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			agentMessage: message,
+			role: DidCommMessageRole.Sender,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		credentialExchangeRecord.credentialAttributes = credentialProposal?.attributes;
+		await credentialRepository.save(agentContext, credentialExchangeRecord);
+		this.emitStateChangedEvent(agentContext, credentialExchangeRecord, null);
+		return {
+			credentialExchangeRecord,
+			message
+		};
+	}
+	/**
+	* Process a received {@link ProposeCredentialMessage}. This will not accept the credential proposal
+	* or send a credential offer. It will only create a new, or update the existing credential record with
+	* the information from the credential proposal message. Use {@link createOfferAsResponse}
+	* after calling this method to create a credential offer.
+	*
+	* @param messageContext The message context containing a credential proposal message
+	* @returns credential record associated with the credential proposal message
+	*
+	*/
+	async processProposal(messageContext) {
+		const { message: proposalMessage, connection, agentContext } = messageContext;
+		const credentialRepository = agentContext.dependencyManager.resolve(DidCommCredentialExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		agentContext.config.logger.debug(`Processing credential proposal with message id ${proposalMessage.id}`);
+		let credentialExchangeRecord = await this.findByProperties(messageContext.agentContext, {
+			threadId: proposalMessage.threadId,
+			role: DidCommCredentialRole.Issuer,
+			connectionId: connection?.id
+		});
+		if (credentialExchangeRecord) {
+			agentContext.config.logger.debug("Credential record already exists for incoming proposal");
+			credentialExchangeRecord.assertProtocolVersion("v1");
+			credentialExchangeRecord.assertState(DidCommCredentialState.OfferSent);
+			const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
+				associatedRecordId: credentialExchangeRecord.id,
+				messageClass: DidCommProposeCredentialV1Message,
+				role: DidCommMessageRole.Receiver
+			});
+			const lastSentMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
+				associatedRecordId: credentialExchangeRecord.id,
+				messageClass: V1OfferCredentialMessage,
+				role: DidCommMessageRole.Sender
+			});
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+				lastReceivedMessage,
+				lastSentMessage,
+				expectedConnectionId: credentialExchangeRecord.connectionId
+			});
+			await this.indyCredentialFormat.processProposal(messageContext.agentContext, {
+				credentialExchangeRecord,
+				attachment: new DidCommAttachment({ data: new DidCommAttachmentData({ json: JsonTransformer.toJSON(this.rfc0592ProposalFromV1ProposeMessage(proposalMessage)) }) })
+			});
+			await this.updateState(messageContext.agentContext, credentialExchangeRecord, DidCommCredentialState.ProposalReceived);
+			await didCommMessageRepository.saveOrUpdateAgentMessage(messageContext.agentContext, {
+				agentMessage: proposalMessage,
+				role: DidCommMessageRole.Receiver,
+				associatedRecordId: credentialExchangeRecord.id
+			});
+		} else {
+			agentContext.config.logger.debug("Credential record does not exists yet for incoming proposal");
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
+			credentialExchangeRecord = new DidCommCredentialExchangeRecord({
+				connectionId: connection?.id,
+				threadId: proposalMessage.threadId,
+				state: DidCommCredentialState.ProposalReceived,
+				role: DidCommCredentialRole.Issuer,
+				protocolVersion: "v1"
+			});
+			await credentialRepository.save(messageContext.agentContext, credentialExchangeRecord);
+			this.emitStateChangedEvent(messageContext.agentContext, credentialExchangeRecord, null);
+			await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
+				agentMessage: proposalMessage,
+				role: DidCommMessageRole.Receiver,
+				associatedRecordId: credentialExchangeRecord.id
+			});
+		}
+		return credentialExchangeRecord;
+	}
+	/**
+	* Processing an incoming credential message and create a credential offer as a response
+	* @param options The object containing config options
+	* @returns Object containing proposal message and associated credential record
+	*/
+	async acceptProposal(agentContext, { credentialExchangeRecord, credentialFormats, comment, autoAcceptCredential }) {
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.ProposalReceived);
+		if (credentialFormats) this.assertOnlyIndyFormat(credentialFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const proposalMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: DidCommProposeCredentialV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		credentialExchangeRecord.credentialAttributes = proposalMessage.credentialPreview?.attributes;
+		const { attachment, previewAttributes } = await this.indyCredentialFormat.acceptProposal(agentContext, {
+			attachmentId: INDY_CREDENTIAL_OFFER_ATTACHMENT_ID,
+			credentialFormats,
+			credentialExchangeRecord,
+			proposalAttachment: new DidCommAttachment({ data: new DidCommAttachmentData({ json: JsonTransformer.toJSON(this.rfc0592ProposalFromV1ProposeMessage(proposalMessage)) }) })
+		});
+		if (!previewAttributes) throw new CredoError("Missing required credential preview attributes from indy format service");
+		const message = new V1OfferCredentialMessage({
+			comment,
+			offerAttachments: [attachment],
+			credentialPreview: new DidCommCredentialV1Preview({ attributes: previewAttributes })
+		});
+		message.setThread({
+			threadId: credentialExchangeRecord.threadId,
+			parentThreadId: credentialExchangeRecord.parentThreadId
+		});
+		credentialExchangeRecord.credentialAttributes = message.credentialPreview.attributes;
+		credentialExchangeRecord.autoAcceptCredential = autoAcceptCredential ?? credentialExchangeRecord.autoAcceptCredential;
+		await this.updateState(agentContext, credentialExchangeRecord, DidCommCredentialState.OfferSent);
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: message,
+			role: DidCommMessageRole.Sender,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		return {
+			credentialExchangeRecord,
+			message
+		};
+	}
+	/**
+	* Negotiate a credential proposal as issuer (by sending a credential offer message) to the connection
+	* associated with the credential record.
+	*
+	* @param options configuration for the offer see {@link NegotiateCredentialProposalOptions}
+	* @returns Credential record associated with the credential offer and the corresponding new offer message
+	*
+	*/
+	async negotiateProposal(agentContext, { credentialFormats, credentialExchangeRecord, comment, autoAcceptCredential }) {
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.ProposalReceived);
+		this.assertOnlyIndyFormat(credentialFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const { attachment, previewAttributes } = await this.indyCredentialFormat.createOffer(agentContext, {
+			attachmentId: INDY_CREDENTIAL_OFFER_ATTACHMENT_ID,
+			credentialFormats,
+			credentialExchangeRecord
+		});
+		if (!previewAttributes) throw new CredoError("Missing required credential preview attributes from indy format service");
+		const message = new V1OfferCredentialMessage({
+			comment,
+			offerAttachments: [attachment],
+			credentialPreview: new DidCommCredentialV1Preview({ attributes: previewAttributes })
+		});
+		message.setThread({
+			threadId: credentialExchangeRecord.threadId,
+			parentThreadId: credentialExchangeRecord.parentThreadId
+		});
+		credentialExchangeRecord.credentialAttributes = message.credentialPreview.attributes;
+		credentialExchangeRecord.autoAcceptCredential = autoAcceptCredential ?? credentialExchangeRecord.autoAcceptCredential;
+		await this.updateState(agentContext, credentialExchangeRecord, DidCommCredentialState.OfferSent);
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: message,
+			role: DidCommMessageRole.Sender,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		return {
+			credentialExchangeRecord,
+			message
+		};
+	}
+	/**
+	* Create a {@link OfferCredentialMessage} not bound to an existing credential exchange.
+	* To create an offer as response to an existing credential exchange, use {@link DidCommCredentialV1Protocol#createOfferAsResponse}.
+	*
+	* @param options The options containing config params for creating the credential offer
+	* @returns Object containing offer message and associated credential record
+	*
+	*/
+	async createOffer(agentContext, { credentialFormats, autoAcceptCredential, comment, connectionRecord }) {
+		this.assertOnlyIndyFormat(credentialFormats);
+		const credentialRepository = agentContext.dependencyManager.resolve(DidCommCredentialExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		if (!credentialFormats.indy) throw new CredoError("Missing indy credential format data for v1 create offer");
+		const credentialExchangeRecord = new DidCommCredentialExchangeRecord({
+			connectionId: connectionRecord?.id,
+			threadId: utils.uuid(),
+			state: DidCommCredentialState.OfferSent,
+			role: DidCommCredentialRole.Issuer,
+			autoAcceptCredential,
+			protocolVersion: "v1"
+		});
+		const { attachment, previewAttributes } = await this.indyCredentialFormat.createOffer(agentContext, {
+			attachmentId: INDY_CREDENTIAL_OFFER_ATTACHMENT_ID,
+			credentialFormats,
+			credentialExchangeRecord
+		});
+		if (!previewAttributes) throw new CredoError("Missing required credential preview from indy format service");
+		const message = new V1OfferCredentialMessage({
+			id: credentialExchangeRecord.threadId,
+			credentialPreview: new DidCommCredentialV1Preview({ attributes: previewAttributes }),
+			comment,
+			offerAttachments: [attachment]
+		});
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			agentMessage: message,
+			role: DidCommMessageRole.Sender
+		});
+		credentialExchangeRecord.credentialAttributes = message.credentialPreview.attributes;
+		await credentialRepository.save(agentContext, credentialExchangeRecord);
+		this.emitStateChangedEvent(agentContext, credentialExchangeRecord, null);
+		return {
+			message,
+			credentialExchangeRecord
+		};
+	}
+	/**
+	* Process a received {@link OfferCredentialMessage}. This will not accept the credential offer
+	* or send a credential request. It will only create a new credential record with
+	* the information from the credential offer message. Use {@link createRequest}
+	* after calling this method to create a credential request.
+	*
+	* @param messageContext The message context containing a credential request message
+	* @returns credential record associated with the credential offer message
+	*
+	*/
+	async processOffer(messageContext) {
+		const { message: offerMessage, connection, agentContext } = messageContext;
+		const credentialRepository = agentContext.dependencyManager.resolve(DidCommCredentialExchangeRepository);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		agentContext.config.logger.debug(`Processing credential offer with id ${offerMessage.id}`);
+		let credentialExchangeRecord = await this.findByProperties(agentContext, {
+			threadId: offerMessage.threadId,
+			role: DidCommCredentialRole.Holder,
+			connectionId: connection?.id
+		});
+		const offerAttachment = offerMessage.getOfferAttachmentById(INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+		if (!offerAttachment) throw new CredoError(`Indy attachment with id ${INDY_CREDENTIAL_OFFER_ATTACHMENT_ID} not found in offer message`);
+		if (credentialExchangeRecord) {
+			const lastSentMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
+				associatedRecordId: credentialExchangeRecord.id,
+				messageClass: DidCommProposeCredentialV1Message,
+				role: DidCommMessageRole.Sender
+			});
+			const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
+				associatedRecordId: credentialExchangeRecord.id,
+				messageClass: V1OfferCredentialMessage,
+				role: DidCommMessageRole.Receiver
+			});
+			credentialExchangeRecord.assertProtocolVersion("v1");
+			credentialExchangeRecord.assertState(DidCommCredentialState.ProposalSent);
+			await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+				lastReceivedMessage,
+				lastSentMessage,
+				expectedConnectionId: credentialExchangeRecord.connectionId
+			});
+			await this.indyCredentialFormat.processOffer(messageContext.agentContext, {
+				credentialExchangeRecord,
+				attachment: offerAttachment
+			});
+			await didCommMessageRepository.saveOrUpdateAgentMessage(messageContext.agentContext, {
+				agentMessage: offerMessage,
+				role: DidCommMessageRole.Receiver,
+				associatedRecordId: credentialExchangeRecord.id
+			});
+			await this.updateState(messageContext.agentContext, credentialExchangeRecord, DidCommCredentialState.OfferReceived);
+			return credentialExchangeRecord;
+		}
+		await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
+		credentialExchangeRecord = new DidCommCredentialExchangeRecord({
+			connectionId: connection?.id,
+			threadId: offerMessage.threadId,
+			parentThreadId: offerMessage.thread?.parentThreadId,
+			state: DidCommCredentialState.OfferReceived,
+			role: DidCommCredentialRole.Holder,
+			protocolVersion: "v1"
+		});
+		await this.indyCredentialFormat.processOffer(messageContext.agentContext, {
+			credentialExchangeRecord,
+			attachment: offerAttachment
+		});
+		await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
+			agentMessage: offerMessage,
+			role: DidCommMessageRole.Receiver,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		await credentialRepository.save(messageContext.agentContext, credentialExchangeRecord);
+		this.emitStateChangedEvent(messageContext.agentContext, credentialExchangeRecord, null);
+		return credentialExchangeRecord;
+	}
+	/**
+	* Create a {@link RequestCredentialMessage} as response to a received credential offer.
+	*
+	* @param options configuration to use for the credential request
+	* @returns Object containing request message and associated credential record
+	*
+	*/
+	async acceptOffer(agentContext, { credentialExchangeRecord, credentialFormats, comment, autoAcceptCredential }) {
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.OfferReceived);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const offerMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: V1OfferCredentialMessage,
+			role: DidCommMessageRole.Receiver
+		});
+		const offerAttachment = offerMessage.getOfferAttachmentById(INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+		if (!offerAttachment) throw new CredoError(`Indy attachment with id ${INDY_CREDENTIAL_OFFER_ATTACHMENT_ID} not found in offer message`);
+		const { attachment } = await this.indyCredentialFormat.acceptOffer(agentContext, {
+			credentialExchangeRecord,
+			credentialFormats,
+			attachmentId: INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID,
+			offerAttachment
+		});
+		const requestMessage = new DidCommRequestCredentialV1Message({
+			comment,
+			requestAttachments: [attachment]
+		});
+		requestMessage.setThread({
+			threadId: credentialExchangeRecord.threadId,
+			parentThreadId: credentialExchangeRecord.parentThreadId
+		});
+		credentialExchangeRecord.credentialAttributes = offerMessage.credentialPreview.attributes;
+		credentialExchangeRecord.autoAcceptCredential = autoAcceptCredential ?? credentialExchangeRecord.autoAcceptCredential;
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: requestMessage,
+			associatedRecordId: credentialExchangeRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		await this.updateState(agentContext, credentialExchangeRecord, DidCommCredentialState.RequestSent);
+		return {
+			message: requestMessage,
+			credentialExchangeRecord
+		};
+	}
+	/**
+	* Process a received {@link RequestCredentialMessage}. This will not accept the credential request
+	* or send a credential. It will only update the existing credential record with
+	* the information from the credential request message. Use {@link createCredential}
+	* after calling this method to create a credential.
+	*
+	* @param messageContext The message context containing a credential request message
+	* @returns credential record associated with the credential request message
+	*
+	*/
+	async negotiateOffer(agentContext, { credentialFormats, credentialExchangeRecord, autoAcceptCredential, comment }) {
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.OfferReceived);
+		this.assertOnlyIndyFormat(credentialFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		if (!credentialExchangeRecord.connectionId) throw new CredoError(`No connectionId found for credential record '${credentialExchangeRecord.id}'. Connection-less issuance does not support negotiation.`);
+		if (!credentialFormats.indy) throw new CredoError("Missing indy credential format in v1 negotiate proposal call.");
+		const { previewAttributes, attachment } = await this.indyCredentialFormat.createProposal(agentContext, {
+			credentialFormats,
+			credentialExchangeRecord
+		});
+		const indyCredentialProposal = JsonTransformer.fromJSON(attachment.getDataAsJson(), AnonCredsCredentialProposal);
+		const credentialProposal = previewAttributes ? new DidCommCredentialV1Preview({ attributes: previewAttributes }) : void 0;
+		const message = new DidCommProposeCredentialV1Message({
+			...indyCredentialProposal,
+			credentialPreview: credentialProposal,
+			comment
+		});
+		message.setThread({
+			threadId: credentialExchangeRecord.threadId,
+			parentThreadId: credentialExchangeRecord.parentThreadId
+		});
+		await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
+			agentMessage: message,
+			role: DidCommMessageRole.Sender,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		credentialExchangeRecord.credentialAttributes = message.credentialPreview?.attributes;
+		credentialExchangeRecord.autoAcceptCredential = autoAcceptCredential ?? credentialExchangeRecord.autoAcceptCredential;
+		await this.updateState(agentContext, credentialExchangeRecord, DidCommCredentialState.ProposalSent);
+		return {
+			credentialExchangeRecord,
+			message
+		};
+	}
+	/**
+	* Starting from a request is not supported in v1 of the issue credential protocol
+	* because indy doesn't allow to start from a request
+	*/
+	async createRequest() {
+		throw new CredoError("Starting from a request is not supported for v1 issue credential protocol");
+	}
+	async processRequest(messageContext) {
+		const { message: requestMessage, connection, agentContext } = messageContext;
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		agentContext.config.logger.debug(`Processing credential request with id ${requestMessage.id}`);
+		const credentialExchangeRecord = await this.getByProperties(messageContext.agentContext, {
+			threadId: requestMessage.threadId,
+			role: DidCommCredentialRole.Issuer
+		});
+		agentContext.config.logger.trace("Credential record found when processing credential request", credentialExchangeRecord);
+		const proposalMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: DidCommProposeCredentialV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const offerMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: V1OfferCredentialMessage,
+			role: DidCommMessageRole.Sender
+		});
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.OfferSent);
+		await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+			lastReceivedMessage: proposalMessage ?? void 0,
+			lastSentMessage: offerMessage ?? void 0,
+			expectedConnectionId: credentialExchangeRecord.connectionId
+		});
+		if (!credentialExchangeRecord.connectionId) {
+			await connectionService.matchIncomingMessageToRequestMessageInOutOfBandExchange(messageContext, { expectedConnectionId: credentialExchangeRecord.connectionId });
+			credentialExchangeRecord.connectionId = connection?.id;
+		}
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) throw new CredoError(`Indy attachment with id ${INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID} not found in request message`);
+		await this.indyCredentialFormat.processRequest(messageContext.agentContext, {
+			credentialExchangeRecord,
+			attachment: requestAttachment
+		});
+		await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
+			agentMessage: requestMessage,
+			role: DidCommMessageRole.Receiver,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		await this.updateState(messageContext.agentContext, credentialExchangeRecord, DidCommCredentialState.RequestReceived);
+		return credentialExchangeRecord;
+	}
+	/**
+	* Create a {@link DidCommIssueCredentialV1Message} as response to a received credential request.
+	*
+	* @returns Object containing issue credential message and associated credential record
+	*
+	*/
+	async acceptRequest(agentContext, { credentialExchangeRecord, credentialFormats, comment, autoAcceptCredential }) {
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.RequestReceived);
+		if (credentialFormats) this.assertOnlyIndyFormat(credentialFormats);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const offerMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: V1OfferCredentialMessage,
+			role: DidCommMessageRole.Sender
+		});
+		const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: DidCommRequestCredentialV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const offerAttachment = offerMessage.getOfferAttachmentById(INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+		if (!offerAttachment || !requestAttachment) throw new CredoError(`Missing data payload in offer or request attachment in credential Record ${credentialExchangeRecord.id}`);
+		const { attachment } = await this.indyCredentialFormat.acceptRequest(agentContext, {
+			credentialExchangeRecord,
+			requestAttachment,
+			offerAttachment,
+			attachmentId: INDY_CREDENTIAL_ATTACHMENT_ID,
+			credentialFormats
+		});
+		const issueMessage = new DidCommIssueCredentialV1Message({
+			comment,
+			credentialAttachments: [attachment]
+		});
+		issueMessage.setThread({
+			threadId: credentialExchangeRecord.threadId,
+			parentThreadId: credentialExchangeRecord.parentThreadId
+		});
+		issueMessage.setPleaseAck();
+		await didCommMessageRepository.saveAgentMessage(agentContext, {
+			agentMessage: issueMessage,
+			associatedRecordId: credentialExchangeRecord.id,
+			role: DidCommMessageRole.Sender
+		});
+		credentialExchangeRecord.autoAcceptCredential = autoAcceptCredential ?? credentialExchangeRecord.autoAcceptCredential;
+		await this.updateState(agentContext, credentialExchangeRecord, DidCommCredentialState.CredentialIssued);
+		return {
+			message: issueMessage,
+			credentialExchangeRecord
+		};
+	}
+	/**
+	* Process an incoming {@link DidCommIssueCredentialV1Message}
+	*
+	* @param messageContext The message context containing a credential acknowledgement message
+	* @returns credential record associated with the credential acknowledgement message
+	*
+	*/
+	async processCredential(messageContext) {
+		const { message: issueMessage, connection, agentContext } = messageContext;
+		agentContext.config.logger.debug(`Processing credential with id ${issueMessage.id}`);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		const credentialExchangeRecord = await this.getByProperties(messageContext.agentContext, {
+			threadId: issueMessage.threadId,
+			role: DidCommCredentialRole.Holder,
+			connectionId: connection?.id
+		});
+		const requestCredentialMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: DidCommRequestCredentialV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		const offerCredentialMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: V1OfferCredentialMessage,
+			role: DidCommMessageRole.Receiver
+		});
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.RequestSent);
+		await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+			lastReceivedMessage: offerCredentialMessage,
+			lastSentMessage: requestCredentialMessage,
+			expectedConnectionId: credentialExchangeRecord.connectionId
+		});
+		const issueAttachment = issueMessage.getCredentialAttachmentById(INDY_CREDENTIAL_ATTACHMENT_ID);
+		if (!issueAttachment) throw new CredoError("Missing indy credential attachment in processCredential");
+		const requestAttachment = requestCredentialMessage?.getRequestAttachmentById(INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) throw new CredoError("Missing indy credential request attachment in processCredential");
+		const offerAttachment = offerCredentialMessage?.getOfferAttachmentById(INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+		if (!offerAttachment) throw new CredoError("Missing indy credential request attachment in processCredential");
+		await this.indyCredentialFormat.processCredential(messageContext.agentContext, {
+			offerAttachment,
+			attachment: issueAttachment,
+			credentialExchangeRecord,
+			requestAttachment
+		});
+		await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
+			agentMessage: issueMessage,
+			role: DidCommMessageRole.Receiver,
+			associatedRecordId: credentialExchangeRecord.id
+		});
+		await this.updateState(messageContext.agentContext, credentialExchangeRecord, DidCommCredentialState.CredentialReceived);
+		return credentialExchangeRecord;
+	}
+	/**
+	* Create a {@link CredentialAckMessage} as response to a received credential.
+	*
+	* @param credentialExchangeRecord The credential record for which to create the credential acknowledgement
+	* @returns Object containing credential acknowledgement message and associated credential record
+	*
+	*/
+	async acceptCredential(agentContext, { credentialExchangeRecord }) {
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.CredentialReceived);
+		const ackMessage = new DidCommCredentialV1AckMessage({
+			status: AckStatus.OK,
+			threadId: credentialExchangeRecord.threadId
+		});
+		ackMessage.setThread({
+			threadId: credentialExchangeRecord.threadId,
+			parentThreadId: credentialExchangeRecord.parentThreadId
+		});
+		await this.updateState(agentContext, credentialExchangeRecord, DidCommCredentialState.Done);
+		return {
+			message: ackMessage,
+			credentialExchangeRecord
+		};
+	}
+	/**
+	* Process a received {@link CredentialAckMessage}.
+	*
+	* @param messageContext The message context containing a credential acknowledgement message
+	* @returns credential record associated with the credential acknowledgement message
+	*
+	*/
+	async processAck(messageContext) {
+		const { message: ackMessage, connection, agentContext } = messageContext;
+		agentContext.config.logger.debug(`Processing credential ack with id ${ackMessage.id}`);
+		const didCommMessageRepository = agentContext.dependencyManager.resolve(DidCommMessageRepository);
+		const connectionService = agentContext.dependencyManager.resolve(DidCommConnectionService);
+		const credentialExchangeRecord = await this.getByProperties(messageContext.agentContext, {
+			threadId: ackMessage.threadId,
+			role: DidCommCredentialRole.Issuer,
+			connectionId: connection?.id
+		});
+		const requestCredentialMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: DidCommRequestCredentialV1Message,
+			role: DidCommMessageRole.Receiver
+		});
+		const issueCredentialMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
+			associatedRecordId: credentialExchangeRecord.id,
+			messageClass: DidCommIssueCredentialV1Message,
+			role: DidCommMessageRole.Sender
+		});
+		credentialExchangeRecord.assertProtocolVersion("v1");
+		credentialExchangeRecord.assertState(DidCommCredentialState.CredentialIssued);
+		await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
+			lastReceivedMessage: requestCredentialMessage,
+			lastSentMessage: issueCredentialMessage,
+			expectedConnectionId: credentialExchangeRecord.connectionId
+		});
+		await this.updateState(messageContext.agentContext, credentialExchangeRecord, DidCommCredentialState.Done);
+		return credentialExchangeRecord;
+	}
+	/**
+	* Create a {@link DidCommCredentialV1ProblemReportMessage} to be sent.
+	*
+	* @param message message to send
+	* @returns a {@link DidCommCredentialV1ProblemReportMessage}
+	*
+	*/
+	async createProblemReport(_agentContext, { credentialExchangeRecord, description }) {
+		return {
+			message: new DidCommCredentialV1ProblemReportMessage({ description: {
+				en: description,
+				code: DidCommCredentialProblemReportReason.IssuanceAbandoned
+			} }),
+			credentialExchangeRecord
+		};
+	}
+	async shouldAutoRespondToProposal(agentContext, options) {
+		const { credentialExchangeRecord, proposalMessage } = options;
+		const credentialsModuleConfig = agentContext.dependencyManager.resolve(DidCommCredentialsModuleConfig);
+		const autoAccept = composeCredentialAutoAccept(credentialExchangeRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
+		if (autoAccept === DidCommAutoAcceptCredential.Always) return true;
+		if (autoAccept === DidCommAutoAcceptCredential.Never) return false;
+		const offerMessage = await this.findOfferMessage(agentContext, credentialExchangeRecord.id);
+		if (!offerMessage || !offerMessage.credentialPreview) return false;
+		if (!proposalMessage.credentialPreview || !proposalMessage.credentialDefinitionId) return false;
+		const credentialOfferJson = offerMessage.indyCredentialOffer;
+		if (!credentialOfferJson) return false;
+		if (credentialOfferJson.cred_def_id !== proposalMessage.credentialDefinitionId) return false;
+		return areCredentialPreviewAttributesEqual(proposalMessage.credentialPreview.attributes, offerMessage.credentialPreview.attributes);
+	}
+	async shouldAutoRespondToOffer(agentContext, options) {
+		const { credentialExchangeRecord, offerMessage } = options;
+		const credentialsModuleConfig = agentContext.dependencyManager.resolve(DidCommCredentialsModuleConfig);
+		const autoAccept = composeCredentialAutoAccept(credentialExchangeRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
+		if (autoAccept === DidCommAutoAcceptCredential.Always) return true;
+		if (autoAccept === DidCommAutoAcceptCredential.Never) return false;
+		const proposalMessage = await this.findProposalMessage(agentContext, credentialExchangeRecord.id);
+		if (!offerMessage.credentialPreview) return false;
+		if (!proposalMessage || !proposalMessage.credentialPreview || !proposalMessage.credentialDefinitionId) return false;
+		const credentialOfferJson = offerMessage.indyCredentialOffer;
+		if (!credentialOfferJson) return false;
+		if (credentialOfferJson.cred_def_id !== proposalMessage.credentialDefinitionId) return false;
+		return areCredentialPreviewAttributesEqual(proposalMessage.credentialPreview.attributes, offerMessage.credentialPreview.attributes);
+	}
+	async shouldAutoRespondToRequest(agentContext, options) {
+		const { credentialExchangeRecord, requestMessage } = options;
+		const credentialsModuleConfig = agentContext.dependencyManager.resolve(DidCommCredentialsModuleConfig);
+		const autoAccept = composeCredentialAutoAccept(credentialExchangeRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
+		if (autoAccept === DidCommAutoAcceptCredential.Always) return true;
+		if (autoAccept === DidCommAutoAcceptCredential.Never) return false;
+		const offerMessage = await this.findOfferMessage(agentContext, credentialExchangeRecord.id);
+		if (!offerMessage) return false;
+		const offerAttachment = offerMessage.getOfferAttachmentById(INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+		const requestAttachment = requestMessage.getRequestAttachmentById(INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+		if (!offerAttachment || !requestAttachment) return false;
+		return this.indyCredentialFormat.shouldAutoRespondToRequest(agentContext, {
+			credentialExchangeRecord,
+			offerAttachment,
+			requestAttachment
+		});
+	}
+	async shouldAutoRespondToCredential(agentContext, options) {
+		const { credentialExchangeRecord, credentialMessage } = options;
+		const credentialsModuleConfig = agentContext.dependencyManager.resolve(DidCommCredentialsModuleConfig);
+		const autoAccept = composeCredentialAutoAccept(credentialExchangeRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
+		if (autoAccept === DidCommAutoAcceptCredential.Always) return true;
+		if (autoAccept === DidCommAutoAcceptCredential.Never) return false;
+		const requestMessage = await this.findRequestMessage(agentContext, credentialExchangeRecord.id);
+		const offerMessage = await this.findOfferMessage(agentContext, credentialExchangeRecord.id);
+		const credentialAttachment = credentialMessage.getCredentialAttachmentById(INDY_CREDENTIAL_ATTACHMENT_ID);
+		if (!credentialAttachment) return false;
+		const requestAttachment = requestMessage?.getRequestAttachmentById(INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+		if (!requestAttachment) return false;
+		const offerAttachment = offerMessage?.getOfferAttachmentById(INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+		return this.indyCredentialFormat.shouldAutoRespondToCredential(agentContext, {
+			credentialExchangeRecord,
+			credentialAttachment,
+			requestAttachment,
+			offerAttachment
+		});
+	}
+	async findProposalMessage(agentContext, credentialExchangeId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeId,
+			messageClass: DidCommProposeCredentialV1Message
+		});
+	}
+	async findOfferMessage(agentContext, credentialExchangeId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeId,
+			messageClass: V1OfferCredentialMessage
+		});
+	}
+	async findRequestMessage(agentContext, credentialExchangeId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeId,
+			messageClass: DidCommRequestCredentialV1Message
+		});
+	}
+	async findCredentialMessage(agentContext, credentialExchangeId) {
+		return await agentContext.dependencyManager.resolve(DidCommMessageRepository).findAgentMessage(agentContext, {
+			associatedRecordId: credentialExchangeId,
+			messageClass: DidCommIssueCredentialV1Message
+		});
+	}
+	async getFormatData(agentContext, credentialExchangeId) {
+		const [proposalMessage, offerMessage, requestMessage, credentialMessage] = await Promise.all([
+			this.findProposalMessage(agentContext, credentialExchangeId),
+			this.findOfferMessage(agentContext, credentialExchangeId),
+			this.findRequestMessage(agentContext, credentialExchangeId),
+			this.findCredentialMessage(agentContext, credentialExchangeId)
+		]);
+		const indyProposal = proposalMessage ? JsonTransformer.toJSON(this.rfc0592ProposalFromV1ProposeMessage(proposalMessage)) : void 0;
+		const indyOffer = offerMessage?.indyCredentialOffer ?? void 0;
+		const indyRequest = requestMessage?.indyCredentialRequest ?? void 0;
+		const indyCredential = credentialMessage?.indyCredential ?? void 0;
+		return {
+			proposalAttributes: proposalMessage?.credentialPreview?.attributes,
+			proposal: proposalMessage ? { indy: indyProposal } : void 0,
+			offerAttributes: offerMessage?.credentialPreview?.attributes,
+			offer: offerMessage ? { indy: indyOffer } : void 0,
+			request: requestMessage ? { indy: indyRequest } : void 0,
+			credential: credentialMessage ? { indy: indyCredential } : void 0
+		};
+	}
+	rfc0592ProposalFromV1ProposeMessage(proposalMessage) {
+		return new AnonCredsCredentialProposal({
+			credentialDefinitionId: proposalMessage.credentialDefinitionId,
+			schemaId: proposalMessage.schemaId,
+			issuerDid: proposalMessage.issuerDid,
+			schemaIssuerDid: proposalMessage.schemaIssuerDid,
+			schemaName: proposalMessage.schemaName,
+			schemaVersion: proposalMessage.schemaVersion
+		});
+	}
+	assertOnlyIndyFormat(credentialFormats) {
+		const formatKeys = Object.keys(credentialFormats);
+		if (formatKeys.length === 0) return;
+		if (formatKeys.length !== 1 || !formatKeys.includes("indy")) throw new CredoError("Only indy credential format is supported for issue credential v1 protocol");
+	}
+	getFormatServiceForRecordType(credentialRecordType) {
+		if (credentialRecordType !== this.indyCredentialFormat.credentialRecordType) throw new CredoError(`Unsupported credential record type ${credentialRecordType} for v1 issue credential protocol (need ${this.indyCredentialFormat.credentialRecordType})`);
+		return this.indyCredentialFormat;
+	}
+};
+
+//#endregion
+export { DidCommCredentialV1Protocol };
+//# sourceMappingURL=DidCommCredentialV1Protocol.mjs.map