@credo-ts/anoncreds 0.6.0-pr-2143-20250106173054 → 0.6.0-pr-2195-20250217183709

package/build/protocols/proofs/v1/V1ProofProtocol.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.V1ProofProtocol = void 0;
 const core_1 = require("@credo-ts/core");
+const didcomm_1 = require("@credo-ts/didcomm");
 const utils_1 = require("../../../utils");
 const errors_1 = require("./errors");
 const handlers_1 = require("./handlers");
 const messages_1 = require("./messages");
 const V1PresentationProblemReportMessage_1 = require("./messages/V1PresentationProblemReportMessage");
 const V1PresentationPreview_1 = require("./models/V1PresentationPreview");
-class V1ProofProtocol extends core_1.BaseProofProtocol {
+class V1ProofProtocol extends didcomm_1.BaseProofProtocol {
     constructor({ indyProofFormat }) {
         super();
         /**
@@ -21,9 +22,9 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
     /**
      * Registers the protocol implementation (handlers, feature registry) on the agent.
      */
-    register(dependencyManager, featureRegistry) {
+    register(messageHandlerRegistry, featureRegistry) {
         // Register message handlers for the Issue Credential V1 Protocol
-        dependencyManager.registerMessageHandlers([
+        messageHandlerRegistry.registerMessageHandlers([
             new handlers_1.V1ProposePresentationHandler(this),
             new handlers_1.V1RequestPresentationHandler(this),
             new handlers_1.V1PresentationHandler(this),
@@ -31,22 +32,21 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             new handlers_1.V1PresentationProblemReportHandler(this),
         ]);
         // Register Present Proof V1 in feature registry, with supported roles
-        featureRegistry.register(new core_1.Protocol({
+        featureRegistry.register(new didcomm_1.Protocol({
             id: 'https://didcomm.org/present-proof/1.0',
             roles: ['prover', 'verifier'],
         }));
     }
     async createProposal(agentContext, { proofFormats, connectionRecord, comment, parentThreadId, autoAcceptProof, }) {
-        var _a, _b, _c;
         this.assertOnlyIndyFormat(proofFormats);
-        const proofRepository = agentContext.dependencyManager.resolve(core_1.ProofRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const proofRepository = agentContext.dependencyManager.resolve(didcomm_1.ProofRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         if (!proofFormats.indy) {
             throw new core_1.CredoError('Missing indy proof format in v1 create proposal call.');
         }
         const presentationProposal = new V1PresentationPreview_1.V1PresentationPreview({
-            attributes: (_a = proofFormats.indy) === null || _a === void 0 ? void 0 : _a.attributes,
-            predicates: (_b = proofFormats.indy) === null || _b === void 0 ? void 0 : _b.predicates,
+            attributes: proofFormats.indy?.attributes,
+            predicates: proofFormats.indy?.predicates,
         });
         // validate input data from user
         core_1.MessageValidator.validateSync(presentationProposal);
@@ -60,53 +60,52 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
                 parentThreadId,
             });
         // Create record
-        const proofRecord = new core_1.ProofExchangeRecord({
+        const proofRecord = new didcomm_1.ProofExchangeRecord({
             connectionId: connectionRecord.id,
             threadId: message.threadId,
-            parentThreadId: (_c = message.thread) === null || _c === void 0 ? void 0 : _c.parentThreadId,
-            state: core_1.ProofState.ProposalSent,
-            role: core_1.ProofRole.Prover,
+            parentThreadId: message.thread?.parentThreadId,
+            state: didcomm_1.ProofState.ProposalSent,
+            role: didcomm_1.ProofRole.Prover,
             autoAcceptProof,
             protocolVersion: 'v1',
         });
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             agentMessage: message,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         await proofRepository.save(agentContext, proofRecord);
         this.emitStateChangedEvent(agentContext, proofRecord, null);
         return { proofRecord, message };
     }
     async processProposal(messageContext) {
-        var _a;
         const { message: proposalMessage, connection, agentContext } = messageContext;
-        const proofRepository = agentContext.dependencyManager.resolve(core_1.ProofRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const proofRepository = agentContext.dependencyManager.resolve(didcomm_1.ProofRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         // TODO: with this method, we should update the credential protocol to use the ConnectionApi, so it
         // only depends on the public api, rather than the internal API (this helps with breaking changes)
-        const connectionService = agentContext.dependencyManager.resolve(core_1.ConnectionService);
+        const connectionService = agentContext.dependencyManager.resolve(didcomm_1.ConnectionService);
         agentContext.config.logger.debug(`Processing presentation proposal with message id ${proposalMessage.id}`);
         let proofRecord = await this.findByProperties(agentContext, {
             threadId: proposalMessage.threadId,
-            role: core_1.ProofRole.Verifier,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.ProofRole.Verifier,
+            connectionId: connection?.id,
         });
         // Proof record already exists, this is a response to an earlier message sent by us
         if (proofRecord) {
             agentContext.config.logger.debug('Proof record already exists for incoming proposal');
             // Assert
-            proofRecord.assertState(core_1.ProofState.RequestSent);
+            proofRecord.assertState(didcomm_1.ProofState.RequestSent);
             proofRecord.assertProtocolVersion('v1');
             const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
                 associatedRecordId: proofRecord.id,
                 messageClass: messages_1.V1ProposePresentationMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
             const lastSentMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
                 associatedRecordId: proofRecord.id,
                 messageClass: messages_1.V1RequestPresentationMessage,
-                role: core_1.DidCommMessageRole.Sender,
+                role: didcomm_1.DidCommMessageRole.Sender,
             });
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
                 lastReceivedMessage,
@@ -117,27 +116,27 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
                 agentMessage: proposalMessage,
                 associatedRecordId: proofRecord.id,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
-            await this.updateState(agentContext, proofRecord, core_1.ProofState.ProposalReceived);
+            await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.ProposalReceived);
         }
         else {
             agentContext.config.logger.debug('Proof record does not exist yet for incoming proposal');
             // Assert
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
             // No proof record exists with thread id
-            proofRecord = new core_1.ProofExchangeRecord({
-                connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            proofRecord = new didcomm_1.ProofExchangeRecord({
+                connectionId: connection?.id,
                 threadId: proposalMessage.threadId,
-                parentThreadId: (_a = proposalMessage.thread) === null || _a === void 0 ? void 0 : _a.parentThreadId,
-                state: core_1.ProofState.ProposalReceived,
-                role: core_1.ProofRole.Verifier,
+                parentThreadId: proposalMessage.thread?.parentThreadId,
+                state: didcomm_1.ProofState.ProposalReceived,
+                role: didcomm_1.ProofRole.Verifier,
                 protocolVersion: 'v1',
             });
             await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
                 agentMessage: proposalMessage,
                 associatedRecordId: proofRecord.id,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
             // Save record
             await proofRepository.save(agentContext, proofRecord);
@@ -146,29 +145,28 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         return proofRecord;
     }
     async acceptProposal(agentContext, { proofRecord, proofFormats, comment, autoAcceptProof, }) {
-        var _a, _b;
         // Assert
         proofRecord.assertProtocolVersion('v1');
-        proofRecord.assertState(core_1.ProofState.ProposalReceived);
+        proofRecord.assertState(didcomm_1.ProofState.ProposalReceived);
         if (proofFormats)
             this.assertOnlyIndyFormat(proofFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const proposalMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1ProposePresentationMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
-        const indyFormat = proofFormats === null || proofFormats === void 0 ? void 0 : proofFormats.indy;
+        const indyFormat = proofFormats?.indy;
         // Create a proof request from the preview, so we can let the messages
         // be handled using the indy proof format which supports RFC0592
         const requestFromPreview = (0, utils_1.createRequestFromPreview)({
             attributes: proposalMessage.presentationProposal.attributes,
             predicates: proposalMessage.presentationProposal.predicates,
-            name: (_a = indyFormat === null || indyFormat === void 0 ? void 0 : indyFormat.name) !== null && _a !== void 0 ? _a : 'Proof Request',
-            version: (_b = indyFormat === null || indyFormat === void 0 ? void 0 : indyFormat.version) !== null && _b !== void 0 ? _b : '1.0',
+            name: indyFormat?.name ?? 'Proof Request',
+            version: indyFormat?.version ?? '1.0',
             nonce: await agentContext.wallet.generateNonce(),
         });
-        const proposalAttachment = new core_1.Attachment({
+        const proposalAttachment = new didcomm_1.Attachment({
             data: {
                 json: core_1.JsonTransformer.toJSON(requestFromPreview),
             },
@@ -190,19 +188,19 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: requestPresentationMessage,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Update record
-        proofRecord.autoAcceptProof = autoAcceptProof !== null && autoAcceptProof !== void 0 ? autoAcceptProof : proofRecord.autoAcceptProof;
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.RequestSent);
+        proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.RequestSent);
         return { message: requestPresentationMessage, proofRecord };
     }
     async negotiateProposal(agentContext, { proofFormats, proofRecord, comment, autoAcceptProof, }) {
         // Assert
         proofRecord.assertProtocolVersion('v1');
-        proofRecord.assertState(core_1.ProofState.ProposalReceived);
+        proofRecord.assertState(didcomm_1.ProofState.ProposalReceived);
         this.assertOnlyIndyFormat(proofFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         // Create message
         const { attachment } = await this.indyProofFormat.createRequest(agentContext, {
             attachmentId: messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID,
@@ -220,26 +218,26 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: requestPresentationMessage,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
-        proofRecord.autoAcceptProof = autoAcceptProof !== null && autoAcceptProof !== void 0 ? autoAcceptProof : proofRecord.autoAcceptProof;
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.RequestSent);
+        proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.RequestSent);
         return { message: requestPresentationMessage, proofRecord };
     }
     async createRequest(agentContext, { proofFormats, connectionRecord, comment, parentThreadId, autoAcceptProof, }) {
         this.assertOnlyIndyFormat(proofFormats);
-        const proofRepository = agentContext.dependencyManager.resolve(core_1.ProofRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const proofRepository = agentContext.dependencyManager.resolve(didcomm_1.ProofRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         if (!proofFormats.indy) {
             throw new core_1.CredoError('Missing indy proof request data for v1 create request');
         }
         // Create record
-        const proofRecord = new core_1.ProofExchangeRecord({
-            connectionId: connectionRecord === null || connectionRecord === void 0 ? void 0 : connectionRecord.id,
+        const proofRecord = new didcomm_1.ProofExchangeRecord({
+            connectionId: connectionRecord?.id,
             threadId: core_1.utils.uuid(),
             parentThreadId,
-            state: core_1.ProofState.RequestSent,
-            role: core_1.ProofRole.Verifier,
+            state: didcomm_1.ProofState.RequestSent,
+            role: didcomm_1.ProofRole.Verifier,
             autoAcceptProof,
             protocolVersion: 'v1',
         });
@@ -262,25 +260,24 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             agentMessage: message,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         await proofRepository.save(agentContext, proofRecord);
         this.emitStateChangedEvent(agentContext, proofRecord, null);
         return { message, proofRecord };
     }
     async processRequest(messageContext) {
-        var _a;
         const { message: proofRequestMessage, connection, agentContext } = messageContext;
-        const proofRepository = agentContext.dependencyManager.resolve(core_1.ProofRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const proofRepository = agentContext.dependencyManager.resolve(didcomm_1.ProofRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         // TODO: with this method, we should update the credential protocol to use the ConnectionApi, so it
         // only depends on the public api, rather than the internal API (this helps with breaking changes)
-        const connectionService = agentContext.dependencyManager.resolve(core_1.ConnectionService);
+        const connectionService = agentContext.dependencyManager.resolve(didcomm_1.ConnectionService);
         agentContext.config.logger.debug(`Processing presentation request with id ${proofRequestMessage.id}`);
         let proofRecord = await this.findByProperties(agentContext, {
             threadId: proofRequestMessage.threadId,
-            role: core_1.ProofRole.Prover,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.ProofRole.Prover,
+            connectionId: connection?.id,
         });
         const requestAttachment = proofRequestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment) {
@@ -291,16 +288,16 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
                 associatedRecordId: proofRecord.id,
                 messageClass: messages_1.V1RequestPresentationMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
             const lastSentMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
                 associatedRecordId: proofRecord.id,
                 messageClass: messages_1.V1ProposePresentationMessage,
-                role: core_1.DidCommMessageRole.Sender,
+                role: didcomm_1.DidCommMessageRole.Sender,
             });
             // Assert
             proofRecord.assertProtocolVersion('v1');
-            proofRecord.assertState(core_1.ProofState.ProposalSent);
+            proofRecord.assertState(didcomm_1.ProofState.ProposalSent);
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
                 lastReceivedMessage,
                 lastSentMessage,
@@ -313,20 +310,20 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
                 agentMessage: proofRequestMessage,
                 associatedRecordId: proofRecord.id,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
-            await this.updateState(agentContext, proofRecord, core_1.ProofState.RequestReceived);
+            await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.RequestReceived);
         }
         else {
             // Assert
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
             // No proof record exists with thread id
-            proofRecord = new core_1.ProofExchangeRecord({
-                connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            proofRecord = new didcomm_1.ProofExchangeRecord({
+                connectionId: connection?.id,
                 threadId: proofRequestMessage.threadId,
-                parentThreadId: (_a = proofRequestMessage.thread) === null || _a === void 0 ? void 0 : _a.parentThreadId,
-                state: core_1.ProofState.RequestReceived,
-                role: core_1.ProofRole.Prover,
+                parentThreadId: proofRequestMessage.thread?.parentThreadId,
+                state: didcomm_1.ProofState.RequestReceived,
+                role: didcomm_1.ProofRole.Prover,
                 protocolVersion: 'v1',
             });
             await this.indyProofFormat.processRequest(agentContext, {
@@ -336,7 +333,7 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             await didCommMessageRepository.saveAgentMessage(agentContext, {
                 agentMessage: proofRequestMessage,
                 associatedRecordId: proofRecord.id,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
             // Save in repository
             await proofRepository.save(agentContext, proofRecord);
@@ -345,12 +342,11 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         return proofRecord;
     }
     async negotiateRequest(agentContext, { proofFormats, proofRecord, comment, autoAcceptProof, }) {
-        var _a, _b;
         // Assert
         proofRecord.assertProtocolVersion('v1');
-        proofRecord.assertState(core_1.ProofState.RequestReceived);
+        proofRecord.assertState(didcomm_1.ProofState.RequestReceived);
         this.assertOnlyIndyFormat(proofFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         if (!proofRecord.connectionId) {
             throw new core_1.CredoError(`No connectionId found for proof record '${proofRecord.id}'. Connection-less verification does not support negotiation.`);
         }
@@ -358,8 +354,8 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             throw new core_1.CredoError('Missing indy proof format in v1 negotiate request call.');
         }
         const presentationProposal = new V1PresentationPreview_1.V1PresentationPreview({
-            attributes: (_a = proofFormats.indy) === null || _a === void 0 ? void 0 : _a.attributes,
-            predicates: (_b = proofFormats.indy) === null || _b === void 0 ? void 0 : _b.predicates,
+            attributes: proofFormats.indy?.attributes,
+            predicates: proofFormats.indy?.predicates,
         });
         // validate input data from user
         core_1.MessageValidator.validateSync(presentationProposal);
@@ -371,40 +367,39 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: message,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Update record
-        proofRecord.autoAcceptProof = autoAcceptProof !== null && autoAcceptProof !== void 0 ? autoAcceptProof : proofRecord.autoAcceptProof;
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.ProposalSent);
+        proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.ProposalSent);
         return { proofRecord, message: message };
     }
     async acceptRequest(agentContext, { proofRecord, proofFormats, autoAcceptProof, comment, }) {
-        var _a, _b;
         // Assert
         proofRecord.assertProtocolVersion('v1');
-        proofRecord.assertState(core_1.ProofState.RequestReceived);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        proofRecord.assertState(didcomm_1.ProofState.RequestReceived);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1RequestPresentationMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1ProposePresentationMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         const indyProofRequest = requestMessage.indyProofRequest;
         if (!requestAttachment || !indyProofRequest) {
-            throw new errors_1.V1PresentationProblemReportError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`, { problemCode: core_1.PresentationProblemReportReason.Abandoned });
+            throw new errors_1.V1PresentationProblemReportError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`, { problemCode: didcomm_1.PresentationProblemReportReason.Abandoned });
         }
         const proposalAttachment = proposalMessage
-            ? new core_1.Attachment({
+            ? new didcomm_1.Attachment({
                 data: {
                     json: core_1.JsonTransformer.toJSON((0, utils_1.createRequestFromPreview)({
-                        attributes: (_a = proposalMessage.presentationProposal) === null || _a === void 0 ? void 0 : _a.attributes,
-                        predicates: (_b = proposalMessage.presentationProposal) === null || _b === void 0 ? void 0 : _b.predicates,
+                        attributes: proposalMessage.presentationProposal?.attributes,
+                        predicates: proposalMessage.presentationProposal?.predicates,
                         name: indyProofRequest.name,
                         nonce: indyProofRequest.nonce,
                         version: indyProofRequest.nonce,
@@ -427,27 +422,26 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             agentMessage: message,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Update record
-        proofRecord.autoAcceptProof = autoAcceptProof !== null && autoAcceptProof !== void 0 ? autoAcceptProof : proofRecord.autoAcceptProof;
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.PresentationSent);
+        proofRecord.autoAcceptProof = autoAcceptProof ?? proofRecord.autoAcceptProof;
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.PresentationSent);
         return { message, proofRecord };
     }
     async getCredentialsForRequest(agentContext, { proofRecord, proofFormats }) {
-        var _a, _b;
         if (proofFormats)
             this.assertOnlyIndyFormat(proofFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1RequestPresentationMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1ProposePresentationMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         const indyProofRequest = requestMessage.indyProofRequest;
@@ -455,11 +449,11 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             throw new core_1.CredoError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`);
         }
         const proposalAttachment = proposalMessage
-            ? new core_1.Attachment({
+            ? new didcomm_1.Attachment({
                 data: {
                     json: core_1.JsonTransformer.toJSON((0, utils_1.createRequestFromPreview)({
-                        attributes: (_a = proposalMessage.presentationProposal) === null || _a === void 0 ? void 0 : _a.attributes,
-                        predicates: (_b = proposalMessage.presentationProposal) === null || _b === void 0 ? void 0 : _b.predicates,
+                        attributes: proposalMessage.presentationProposal?.attributes,
+                        predicates: proposalMessage.presentationProposal?.predicates,
                         name: indyProofRequest.name,
                         nonce: indyProofRequest.nonce,
                         version: indyProofRequest.nonce,
@@ -480,19 +474,18 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         };
     }
     async selectCredentialsForRequest(agentContext, { proofRecord, proofFormats, }) {
-        var _a, _b;
         if (proofFormats)
             this.assertOnlyIndyFormat(proofFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1RequestPresentationMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1ProposePresentationMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         const indyProofRequest = requestMessage.indyProofRequest;
@@ -500,11 +493,11 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             throw new core_1.CredoError(`Missing indy attachment in request message for presentation with thread id ${proofRecord.threadId}`);
         }
         const proposalAttachment = proposalMessage
-            ? new core_1.Attachment({
+            ? new didcomm_1.Attachment({
                 data: {
                     json: core_1.JsonTransformer.toJSON((0, utils_1.createRequestFromPreview)({
-                        attributes: (_a = proposalMessage.presentationProposal) === null || _a === void 0 ? void 0 : _a.attributes,
-                        predicates: (_b = proposalMessage.presentationProposal) === null || _b === void 0 ? void 0 : _b.predicates,
+                        attributes: proposalMessage.presentationProposal?.attributes,
+                        predicates: proposalMessage.presentationProposal?.predicates,
                         name: indyProofRequest.name,
                         nonce: indyProofRequest.nonce,
                         version: indyProofRequest.nonce,
@@ -525,29 +518,28 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         };
     }
     async processPresentation(messageContext) {
-        var _a;
         const { message: presentationMessage, connection, agentContext } = messageContext;
         agentContext.config.logger.debug(`Processing presentation with message id ${presentationMessage.id}`);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         // TODO: with this method, we should update the credential protocol to use the ConnectionApi, so it
         // only depends on the public api, rather than the internal API (this helps with breaking changes)
-        const connectionService = agentContext.dependencyManager.resolve(core_1.ConnectionService);
+        const connectionService = agentContext.dependencyManager.resolve(didcomm_1.ConnectionService);
         const proofRecord = await this.getByProperties(agentContext, {
             threadId: presentationMessage.threadId,
-            role: core_1.ProofRole.Verifier,
+            role: didcomm_1.ProofRole.Verifier,
         });
         const proposalMessage = await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1ProposePresentationMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1RequestPresentationMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Assert
-        proofRecord.assertState(core_1.ProofState.RequestSent);
+        proofRecord.assertState(didcomm_1.ProofState.RequestSent);
         proofRecord.assertProtocolVersion('v1');
         await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
             lastReceivedMessage: proposalMessage,
@@ -559,28 +551,28 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             await connectionService.matchIncomingMessageToRequestMessageInOutOfBandExchange(messageContext, {
                 expectedConnectionId: proofRecord.connectionId,
             });
-            proofRecord.connectionId = connection === null || connection === void 0 ? void 0 : connection.id;
+            proofRecord.connectionId = connection?.id;
         }
         const presentationAttachment = presentationMessage.getPresentationAttachmentById(messages_1.INDY_PROOF_ATTACHMENT_ID);
         if (!presentationAttachment) {
             proofRecord.errorMessage = 'Missing indy proof attachment';
-            await this.updateState(agentContext, proofRecord, core_1.ProofState.Abandoned);
+            await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.Abandoned);
             throw new errors_1.V1PresentationProblemReportError(proofRecord.errorMessage, {
-                problemCode: core_1.PresentationProblemReportReason.Abandoned,
+                problemCode: didcomm_1.PresentationProblemReportReason.Abandoned,
             });
         }
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment) {
             proofRecord.errorMessage = 'Missing indy proof request attachment';
-            await this.updateState(agentContext, proofRecord, core_1.ProofState.Abandoned);
+            await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.Abandoned);
             throw new errors_1.V1PresentationProblemReportError(proofRecord.errorMessage, {
-                problemCode: core_1.PresentationProblemReportReason.Abandoned,
+                problemCode: didcomm_1.PresentationProblemReportReason.Abandoned,
             });
         }
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             agentMessage: presentationMessage,
             associatedRecordId: proofRecord.id,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         let isValid;
         try {
@@ -591,34 +583,34 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             });
         }
         catch (error) {
-            proofRecord.errorMessage = (_a = error.message) !== null && _a !== void 0 ? _a : 'Error verifying proof on presentation';
+            proofRecord.errorMessage = error.message ?? 'Error verifying proof on presentation';
             proofRecord.isVerified = false;
-            await this.updateState(agentContext, proofRecord, core_1.ProofState.Abandoned);
+            await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.Abandoned);
             throw new errors_1.V1PresentationProblemReportError('Error verifying proof on presentation', {
-                problemCode: core_1.PresentationProblemReportReason.Abandoned,
+                problemCode: didcomm_1.PresentationProblemReportReason.Abandoned,
             });
         }
         if (!isValid) {
             proofRecord.errorMessage = 'Invalid proof';
             proofRecord.isVerified = false;
-            await this.updateState(agentContext, proofRecord, core_1.ProofState.Abandoned);
+            await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.Abandoned);
             throw new errors_1.V1PresentationProblemReportError('Invalid proof', {
-                problemCode: core_1.PresentationProblemReportReason.Abandoned,
+                problemCode: didcomm_1.PresentationProblemReportReason.Abandoned,
             });
         }
         // Update record
         proofRecord.isVerified = isValid;
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.PresentationReceived);
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.PresentationReceived);
         return proofRecord;
     }
     async acceptPresentation(agentContext, { proofRecord }) {
         agentContext.config.logger.debug(`Creating presentation ack for proof record with id ${proofRecord.id}`);
         // Assert
         proofRecord.assertProtocolVersion('v1');
-        proofRecord.assertState(core_1.ProofState.PresentationReceived);
+        proofRecord.assertState(didcomm_1.ProofState.PresentationReceived);
         // Create message
         const ackMessage = new messages_1.V1PresentationAckMessage({
-            status: core_1.AckStatus.OK,
+            status: didcomm_1.AckStatus.OK,
             threadId: proofRecord.threadId,
         });
         ackMessage.setThread({
@@ -626,47 +618,47 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             parentThreadId: proofRecord.parentThreadId,
         });
         // Update record
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.Done);
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.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(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         // TODO: with this method, we should update the credential protocol to use the ConnectionApi, so it
         // only depends on the public api, rather than the internal API (this helps with breaking changes)
-        const connectionService = agentContext.dependencyManager.resolve(core_1.ConnectionService);
+        const connectionService = agentContext.dependencyManager.resolve(didcomm_1.ConnectionService);
         const proofRecord = await this.getByProperties(agentContext, {
             threadId: presentationAckMessage.threadId,
-            role: core_1.ProofRole.Prover,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.ProofRole.Prover,
+            connectionId: connection?.id,
         });
         const lastReceivedMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1RequestPresentationMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const lastSentMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: proofRecord.id,
             messageClass: messages_1.V1PresentationMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Assert
         proofRecord.assertProtocolVersion('v1');
-        proofRecord.assertState(core_1.ProofState.PresentationSent);
+        proofRecord.assertState(didcomm_1.ProofState.PresentationSent);
         await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
             lastReceivedMessage,
             lastSentMessage,
             expectedConnectionId: proofRecord.connectionId,
         });
         // Update record
-        await this.updateState(agentContext, proofRecord, core_1.ProofState.Done);
+        await this.updateState(agentContext, proofRecord, didcomm_1.ProofState.Done);
         return proofRecord;
     }
     async createProblemReport(_agentContext, { proofRecord, description }) {
         const message = new V1PresentationProblemReportMessage_1.V1PresentationProblemReportMessage({
             description: {
-                code: core_1.PresentationProblemReportReason.Abandoned,
+                code: didcomm_1.PresentationProblemReportReason.Abandoned,
                 en: description,
             },
         });
@@ -681,16 +673,16 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
     }
     async shouldAutoRespondToProposal(agentContext, options) {
         const { proofRecord, proposalMessage } = options;
-        const proofsModuleConfig = agentContext.dependencyManager.resolve(core_1.ProofsModuleConfig);
+        const proofsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.ProofsModuleConfig);
         const autoAccept = (0, utils_1.composeProofAutoAccept)(proofRecord.autoAcceptProof, proofsModuleConfig.autoAcceptProofs);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptProof.Always)
+        if (autoAccept === didcomm_1.AutoAcceptProof.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptProof.Never)
+        if (autoAccept === didcomm_1.AutoAcceptProof.Never)
             return false;
         // We are in the ContentApproved case. We need to make sure we've sent a request, and it matches the proposal
         const requestMessage = await this.findRequestMessage(agentContext, proofRecord.id);
-        const requestAttachment = requestMessage === null || requestMessage === void 0 ? void 0 : requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
+        const requestAttachment = requestMessage?.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment)
             return false;
         const rfc0592Proposal = core_1.JsonTransformer.toJSON((0, utils_1.createRequestFromPreview)({
@@ -702,7 +694,7 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         }));
         return this.indyProofFormat.shouldAutoRespondToProposal(agentContext, {
             proofRecord,
-            proposalAttachment: new core_1.Attachment({
+            proposalAttachment: new didcomm_1.Attachment({
                 data: {
                     json: rfc0592Proposal,
                 },
@@ -712,12 +704,12 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
     }
     async shouldAutoRespondToRequest(agentContext, options) {
         const { proofRecord, requestMessage } = options;
-        const proofsModuleConfig = agentContext.dependencyManager.resolve(core_1.ProofsModuleConfig);
+        const proofsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.ProofsModuleConfig);
         const autoAccept = (0, utils_1.composeProofAutoAccept)(proofRecord.autoAcceptProof, proofsModuleConfig.autoAcceptProofs);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptProof.Always)
+        if (autoAccept === didcomm_1.AutoAcceptProof.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptProof.Never)
+        if (autoAccept === didcomm_1.AutoAcceptProof.Never)
             return false;
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment)
@@ -735,7 +727,7 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         });
         return this.indyProofFormat.shouldAutoRespondToRequest(agentContext, {
             proofRecord,
-            proposalAttachment: new core_1.Attachment({
+            proposalAttachment: new didcomm_1.Attachment({
                 data: {
                     base64: core_1.JsonEncoder.toBase64(rfc0592Proposal),
                 },
@@ -745,19 +737,19 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
     }
     async shouldAutoRespondToPresentation(agentContext, options) {
         const { proofRecord, presentationMessage } = options;
-        const proofsModuleConfig = agentContext.dependencyManager.resolve(core_1.ProofsModuleConfig);
+        const proofsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.ProofsModuleConfig);
         const autoAccept = (0, utils_1.composeProofAutoAccept)(proofRecord.autoAcceptProof, proofsModuleConfig.autoAcceptProofs);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptProof.Always)
+        if (autoAccept === didcomm_1.AutoAcceptProof.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptProof.Never)
+        if (autoAccept === didcomm_1.AutoAcceptProof.Never)
             return false;
         const presentationAttachment = presentationMessage.getPresentationAttachmentById(messages_1.INDY_PROOF_ATTACHMENT_ID);
         if (!presentationAttachment)
             return false;
         // We are in the ContentApproved case. We need to make sure we've sent a request, and it matches the presentation
         const requestMessage = await this.findRequestMessage(agentContext, proofRecord.id);
-        const requestAttachment = requestMessage === null || requestMessage === void 0 ? void 0 : requestMessage.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
+        const requestAttachment = requestMessage?.getRequestAttachmentById(messages_1.INDY_PROOF_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment)
             return false;
         // We are in the ContentApproved case. We need to make sure we've sent a proposal, and it matches the request
@@ -775,7 +767,7 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             proofRecord,
             requestAttachment,
             presentationAttachment,
-            proposalAttachment: new core_1.Attachment({
+            proposalAttachment: new didcomm_1.Attachment({
                 data: {
                     json: rfc0592Proposal,
                 },
@@ -783,28 +775,27 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
         });
     }
     async findProposalMessage(agentContext, proofRecordId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecordId,
             messageClass: messages_1.V1ProposePresentationMessage,
         });
     }
     async findRequestMessage(agentContext, proofRecordId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecordId,
             messageClass: messages_1.V1RequestPresentationMessage,
         });
     }
     async findPresentationMessage(agentContext, proofRecordId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: proofRecordId,
             messageClass: messages_1.V1PresentationMessage,
         });
     }
     async getFormatData(agentContext, proofRecordId) {
-        var _a, _b;
         // TODO: we could looking at fetching all record using a single query and then filtering based on the type of the message.
         const [proposalMessage, requestMessage, presentationMessage] = await Promise.all([
             this.findProposalMessage(agentContext, proofRecordId),
@@ -812,8 +803,8 @@ class V1ProofProtocol extends core_1.BaseProofProtocol {
             this.findPresentationMessage(agentContext, proofRecordId),
         ]);
         let indyProposeProof = undefined;
-        const indyRequestProof = (_a = requestMessage === null || requestMessage === void 0 ? void 0 : requestMessage.indyProofRequest) !== null && _a !== void 0 ? _a : undefined;
-        const indyPresentProof = (_b = presentationMessage === null || presentationMessage === void 0 ? void 0 : presentationMessage.indyProof) !== null && _b !== void 0 ? _b : undefined;
+        const indyRequestProof = requestMessage?.indyProofRequest ?? undefined;
+        const indyPresentProof = presentationMessage?.indyProof ?? undefined;
         if (proposalMessage && indyRequestProof) {
             indyProposeProof = (0, utils_1.createRequestFromPreview)({
                 name: indyRequestProof.name,