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

package/build/protocols/credentials/v1/V1CredentialProtocol.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.V1CredentialProtocol = void 0;
 const core_1 = require("@credo-ts/core");
+const didcomm_1 = require("@credo-ts/didcomm");
 const AnonCredsCredentialProposal_1 = require("../../../models/AnonCredsCredentialProposal");
 const utils_1 = require("../../../utils");
 const handlers_1 = require("./handlers");
 const messages_1 = require("./messages");
-class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
+class V1CredentialProtocol extends didcomm_1.BaseCredentialProtocol {
     constructor({ indyCredentialFormat }) {
         super();
         /**
@@ -19,9 +20,9 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     /**
      * 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.V1ProposeCredentialHandler(this),
             new handlers_1.V1OfferCredentialHandler(this),
             new handlers_1.V1RequestCredentialHandler(this),
@@ -30,7 +31,7 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             new handlers_1.V1CredentialProblemReportHandler(this),
         ]);
         // Register Issue Credential V1 in feature registry, with supported roles
-        featureRegistry.register(new core_1.Protocol({
+        featureRegistry.register(new didcomm_1.Protocol({
             id: 'https://didcomm.org/issue-credential/1.0',
             roles: ['holder', 'issuer'],
         }));
@@ -45,8 +46,8 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      */
     async createProposal(agentContext, { connectionRecord, credentialFormats, comment, autoAcceptCredential, }) {
         this.assertOnlyIndyFormat(credentialFormats);
-        const credentialRepository = agentContext.dependencyManager.resolve(core_1.CredentialRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const credentialRepository = agentContext.dependencyManager.resolve(didcomm_1.CredentialRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         if (!credentialFormats.indy) {
             throw new core_1.CredoError('Missing indy credential format in v1 create proposal call.');
         }
@@ -54,12 +55,12 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         // The linking with previews does work, so it shouldn't be too much work to re-enable this.
         const { linkedAttachments } = credentialFormats.indy;
         // Create record
-        const credentialRecord = new core_1.CredentialExchangeRecord({
+        const credentialRecord = new didcomm_1.CredentialExchangeRecord({
             connectionId: connectionRecord.id,
             threadId: core_1.utils.uuid(),
-            state: core_1.CredentialState.ProposalSent,
-            role: core_1.CredentialRole.Holder,
-            linkedAttachments: linkedAttachments === null || linkedAttachments === void 0 ? void 0 : linkedAttachments.map((linkedAttachment) => linkedAttachment.attachment),
+            state: didcomm_1.CredentialState.ProposalSent,
+            role: didcomm_1.CredentialRole.Holder,
+            linkedAttachments: linkedAttachments?.map((linkedAttachment) => linkedAttachment.attachment),
             autoAcceptCredential,
             protocolVersion: 'v1',
         });
@@ -76,13 +77,18 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             })
             : undefined;
         // Create message
-        const message = new messages_1.V1ProposeCredentialMessage(Object.assign(Object.assign({}, indyCredentialProposal), { id: credentialRecord.threadId, credentialPreview: credentialProposal, comment }));
+        const message = new messages_1.V1ProposeCredentialMessage({
+            ...indyCredentialProposal,
+            id: credentialRecord.threadId,
+            credentialPreview: credentialProposal,
+            comment,
+        });
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             agentMessage: message,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
             associatedRecordId: credentialRecord.id,
         });
-        credentialRecord.credentialAttributes = credentialProposal === null || credentialProposal === void 0 ? void 0 : credentialProposal.attributes;
+        credentialRecord.credentialAttributes = credentialProposal?.attributes;
         await credentialRepository.save(agentContext, credentialRecord);
         this.emitStateChangedEvent(agentContext, credentialRecord, null);
         return { credentialRecord, message };
@@ -99,32 +105,32 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      */
     async processProposal(messageContext) {
         const { message: proposalMessage, connection, agentContext } = messageContext;
-        const credentialRepository = agentContext.dependencyManager.resolve(core_1.CredentialRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const credentialRepository = agentContext.dependencyManager.resolve(didcomm_1.CredentialRepository);
+        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 credential proposal with message id ${proposalMessage.id}`);
         let credentialRecord = await this.findByProperties(messageContext.agentContext, {
             threadId: proposalMessage.threadId,
-            role: core_1.CredentialRole.Issuer,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.CredentialRole.Issuer,
+            connectionId: connection?.id,
         });
         // Credential record already exists, this is a response to an earlier message sent by us
         if (credentialRecord) {
             agentContext.config.logger.debug('Credential record already exists for incoming proposal');
             // Assert
             credentialRecord.assertProtocolVersion('v1');
-            credentialRecord.assertState(core_1.CredentialState.OfferSent);
+            credentialRecord.assertState(didcomm_1.CredentialState.OfferSent);
             const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
                 associatedRecordId: credentialRecord.id,
                 messageClass: messages_1.V1ProposeCredentialMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
             const lastSentMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
                 associatedRecordId: credentialRecord.id,
                 messageClass: messages_1.V1OfferCredentialMessage,
-                role: core_1.DidCommMessageRole.Sender,
+                role: didcomm_1.DidCommMessageRole.Sender,
             });
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
                 lastReceivedMessage,
@@ -133,17 +139,17 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             });
             await this.indyCredentialFormat.processProposal(messageContext.agentContext, {
                 credentialRecord,
-                attachment: new core_1.Attachment({
-                    data: new core_1.AttachmentData({
+                attachment: new didcomm_1.Attachment({
+                    data: new didcomm_1.AttachmentData({
                         json: core_1.JsonTransformer.toJSON(this.rfc0592ProposalFromV1ProposeMessage(proposalMessage)),
                     }),
                 }),
             });
             // Update record
-            await this.updateState(messageContext.agentContext, credentialRecord, core_1.CredentialState.ProposalReceived);
+            await this.updateState(messageContext.agentContext, credentialRecord, didcomm_1.CredentialState.ProposalReceived);
             await didCommMessageRepository.saveOrUpdateAgentMessage(messageContext.agentContext, {
                 agentMessage: proposalMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
                 associatedRecordId: credentialRecord.id,
             });
         }
@@ -152,11 +158,11 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             // Assert
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
             // No credential record exists with thread id
-            credentialRecord = new core_1.CredentialExchangeRecord({
-                connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            credentialRecord = new didcomm_1.CredentialExchangeRecord({
+                connectionId: connection?.id,
                 threadId: proposalMessage.threadId,
-                state: core_1.CredentialState.ProposalReceived,
-                role: core_1.CredentialRole.Issuer,
+                state: didcomm_1.CredentialState.ProposalReceived,
+                role: didcomm_1.CredentialRole.Issuer,
                 protocolVersion: 'v1',
             });
             // Save record
@@ -164,7 +170,7 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             this.emitStateChangedEvent(messageContext.agentContext, credentialRecord, null);
             await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
                 agentMessage: proposalMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
                 associatedRecordId: credentialRecord.id,
             });
         }
@@ -176,28 +182,27 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      * @returns Object containing proposal message and associated credential record
      */
     async acceptProposal(agentContext, { credentialRecord, credentialFormats, comment, autoAcceptCredential, }) {
-        var _a;
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.ProposalReceived);
+        credentialRecord.assertState(didcomm_1.CredentialState.ProposalReceived);
         if (credentialFormats)
             this.assertOnlyIndyFormat(credentialFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const proposalMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1ProposeCredentialMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         // NOTE: We set the credential attributes from the proposal on the record as we've 'accepted' them
         // and can now use them to create the offer in the format services. It may be overwritten later on
         // if the user provided other attributes in the credentialFormats array.
-        credentialRecord.credentialAttributes = (_a = proposalMessage.credentialPreview) === null || _a === void 0 ? void 0 : _a.attributes;
+        credentialRecord.credentialAttributes = proposalMessage.credentialPreview?.attributes;
         const { attachment, previewAttributes } = await this.indyCredentialFormat.acceptProposal(agentContext, {
             attachmentId: messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID,
             credentialFormats,
             credentialRecord,
-            proposalAttachment: new core_1.Attachment({
-                data: new core_1.AttachmentData({
+            proposalAttachment: new didcomm_1.Attachment({
+                data: new didcomm_1.AttachmentData({
                     json: core_1.JsonTransformer.toJSON(this.rfc0592ProposalFromV1ProposeMessage(proposalMessage)),
                 }),
             }),
@@ -215,11 +220,11 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         });
         message.setThread({ threadId: credentialRecord.threadId, parentThreadId: credentialRecord.parentThreadId });
         credentialRecord.credentialAttributes = message.credentialPreview.attributes;
-        credentialRecord.autoAcceptCredential = autoAcceptCredential !== null && autoAcceptCredential !== void 0 ? autoAcceptCredential : credentialRecord.autoAcceptCredential;
-        await this.updateState(agentContext, credentialRecord, core_1.CredentialState.OfferSent);
+        credentialRecord.autoAcceptCredential = autoAcceptCredential ?? credentialRecord.autoAcceptCredential;
+        await this.updateState(agentContext, credentialRecord, didcomm_1.CredentialState.OfferSent);
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: message,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
             associatedRecordId: credentialRecord.id,
         });
         return { credentialRecord, message };
@@ -235,9 +240,9 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     async negotiateProposal(agentContext, { credentialFormats, credentialRecord, comment, autoAcceptCredential, }) {
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.ProposalReceived);
+        credentialRecord.assertState(didcomm_1.CredentialState.ProposalReceived);
         this.assertOnlyIndyFormat(credentialFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const { attachment, previewAttributes } = await this.indyCredentialFormat.createOffer(agentContext, {
             attachmentId: messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID,
             credentialFormats,
@@ -256,11 +261,11 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         });
         message.setThread({ threadId: credentialRecord.threadId, parentThreadId: credentialRecord.parentThreadId });
         credentialRecord.credentialAttributes = message.credentialPreview.attributes;
-        credentialRecord.autoAcceptCredential = autoAcceptCredential !== null && autoAcceptCredential !== void 0 ? autoAcceptCredential : credentialRecord.autoAcceptCredential;
-        await this.updateState(agentContext, credentialRecord, core_1.CredentialState.OfferSent);
+        credentialRecord.autoAcceptCredential = autoAcceptCredential ?? credentialRecord.autoAcceptCredential;
+        await this.updateState(agentContext, credentialRecord, didcomm_1.CredentialState.OfferSent);
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: message,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
             associatedRecordId: credentialRecord.id,
         });
         return { credentialRecord, message };
@@ -274,21 +279,20 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      *
      */
     async createOffer(agentContext, { credentialFormats, autoAcceptCredential, comment, connectionRecord, }) {
-        var _a, _b;
         // Assert
         this.assertOnlyIndyFormat(credentialFormats);
-        const credentialRepository = agentContext.dependencyManager.resolve(core_1.CredentialRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const credentialRepository = agentContext.dependencyManager.resolve(didcomm_1.CredentialRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         if (!credentialFormats.indy) {
             throw new core_1.CredoError('Missing indy credential format data for v1 create offer');
         }
         // Create record
-        const credentialRecord = new core_1.CredentialExchangeRecord({
-            connectionId: connectionRecord === null || connectionRecord === void 0 ? void 0 : connectionRecord.id,
+        const credentialRecord = new didcomm_1.CredentialExchangeRecord({
+            connectionId: connectionRecord?.id,
             threadId: core_1.utils.uuid(),
-            linkedAttachments: (_a = credentialFormats.indy.linkedAttachments) === null || _a === void 0 ? void 0 : _a.map((linkedAttachments) => linkedAttachments.attachment),
-            state: core_1.CredentialState.OfferSent,
-            role: core_1.CredentialRole.Issuer,
+            linkedAttachments: credentialFormats.indy.linkedAttachments?.map((linkedAttachments) => linkedAttachments.attachment),
+            state: didcomm_1.CredentialState.OfferSent,
+            role: didcomm_1.CredentialRole.Issuer,
             autoAcceptCredential,
             protocolVersion: 'v1',
         });
@@ -308,12 +312,12 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             }),
             comment,
             offerAttachments: [attachment],
-            attachments: (_b = credentialFormats.indy.linkedAttachments) === null || _b === void 0 ? void 0 : _b.map((linkedAttachments) => linkedAttachments.attachment),
+            attachments: credentialFormats.indy.linkedAttachments?.map((linkedAttachments) => linkedAttachments.attachment),
         });
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             associatedRecordId: credentialRecord.id,
             agentMessage: message,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         credentialRecord.credentialAttributes = message.credentialPreview.attributes;
         await credentialRepository.save(agentContext, credentialRecord);
@@ -331,18 +335,17 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      *
      */
     async processOffer(messageContext) {
-        var _a;
         const { message: offerMessage, connection, agentContext } = messageContext;
-        const credentialRepository = agentContext.dependencyManager.resolve(core_1.CredentialRepository);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const credentialRepository = agentContext.dependencyManager.resolve(didcomm_1.CredentialRepository);
+        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 credential offer with id ${offerMessage.id}`);
         let credentialRecord = await this.findByProperties(agentContext, {
             threadId: offerMessage.threadId,
-            role: core_1.CredentialRole.Holder,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.CredentialRole.Holder,
+            connectionId: connection?.id,
         });
         const offerAttachment = offerMessage.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
         if (!offerAttachment) {
@@ -352,16 +355,16 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             const lastSentMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
                 associatedRecordId: credentialRecord.id,
                 messageClass: messages_1.V1ProposeCredentialMessage,
-                role: core_1.DidCommMessageRole.Sender,
+                role: didcomm_1.DidCommMessageRole.Sender,
             });
             const lastReceivedMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
                 associatedRecordId: credentialRecord.id,
                 messageClass: messages_1.V1OfferCredentialMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
             });
             // Assert
             credentialRecord.assertProtocolVersion('v1');
-            credentialRecord.assertState(core_1.CredentialState.ProposalSent);
+            credentialRecord.assertState(didcomm_1.CredentialState.ProposalSent);
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
                 lastReceivedMessage,
                 lastSentMessage,
@@ -373,22 +376,22 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             });
             await didCommMessageRepository.saveOrUpdateAgentMessage(messageContext.agentContext, {
                 agentMessage: offerMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
                 associatedRecordId: credentialRecord.id,
             });
-            await this.updateState(messageContext.agentContext, credentialRecord, core_1.CredentialState.OfferReceived);
+            await this.updateState(messageContext.agentContext, credentialRecord, didcomm_1.CredentialState.OfferReceived);
             return credentialRecord;
         }
         else {
             // Assert
             await connectionService.assertConnectionOrOutOfBandExchange(messageContext);
             // No credential record exists with thread id
-            credentialRecord = new core_1.CredentialExchangeRecord({
-                connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            credentialRecord = new didcomm_1.CredentialExchangeRecord({
+                connectionId: connection?.id,
                 threadId: offerMessage.threadId,
-                parentThreadId: (_a = offerMessage.thread) === null || _a === void 0 ? void 0 : _a.parentThreadId,
-                state: core_1.CredentialState.OfferReceived,
-                role: core_1.CredentialRole.Holder,
+                parentThreadId: offerMessage.thread?.parentThreadId,
+                state: didcomm_1.CredentialState.OfferReceived,
+                role: didcomm_1.CredentialRole.Holder,
                 protocolVersion: 'v1',
             });
             await this.indyCredentialFormat.processOffer(messageContext.agentContext, {
@@ -398,7 +401,7 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             // Save in repository
             await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
                 agentMessage: offerMessage,
-                role: core_1.DidCommMessageRole.Receiver,
+                role: didcomm_1.DidCommMessageRole.Receiver,
                 associatedRecordId: credentialRecord.id,
             });
             await credentialRepository.save(messageContext.agentContext, credentialRecord);
@@ -414,15 +417,14 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      *
      */
     async acceptOffer(agentContext, { credentialRecord, credentialFormats, comment, autoAcceptCredential, }) {
-        var _a, _b;
         // Assert credential
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.OfferReceived);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        credentialRecord.assertState(didcomm_1.CredentialState.OfferReceived);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const offerMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1OfferCredentialMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const offerAttachment = offerMessage.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
         if (!offerAttachment) {
@@ -437,18 +439,18 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         const requestMessage = new messages_1.V1RequestCredentialMessage({
             comment,
             requestAttachments: [attachment],
-            attachments: (_a = offerMessage.appendedAttachments) === null || _a === void 0 ? void 0 : _a.filter((attachment) => (0, core_1.isLinkedAttachment)(attachment)),
+            attachments: offerMessage.appendedAttachments?.filter((attachment) => (0, didcomm_1.isLinkedAttachment)(attachment)),
         });
         requestMessage.setThread({ threadId: credentialRecord.threadId, parentThreadId: credentialRecord.parentThreadId });
         credentialRecord.credentialAttributes = offerMessage.credentialPreview.attributes;
-        credentialRecord.autoAcceptCredential = autoAcceptCredential !== null && autoAcceptCredential !== void 0 ? autoAcceptCredential : credentialRecord.autoAcceptCredential;
-        credentialRecord.linkedAttachments = (_b = offerMessage.appendedAttachments) === null || _b === void 0 ? void 0 : _b.filter((attachment) => (0, core_1.isLinkedAttachment)(attachment));
+        credentialRecord.autoAcceptCredential = autoAcceptCredential ?? credentialRecord.autoAcceptCredential;
+        credentialRecord.linkedAttachments = offerMessage.appendedAttachments?.filter((attachment) => (0, didcomm_1.isLinkedAttachment)(attachment));
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: requestMessage,
             associatedRecordId: credentialRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
-        await this.updateState(agentContext, credentialRecord, core_1.CredentialState.RequestSent);
+        await this.updateState(agentContext, credentialRecord, didcomm_1.CredentialState.RequestSent);
         return { message: requestMessage, credentialRecord };
     }
     /**
@@ -462,12 +464,11 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      *
      */
     async negotiateOffer(agentContext, { credentialFormats, credentialRecord, autoAcceptCredential, comment, }) {
-        var _a;
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.OfferReceived);
+        credentialRecord.assertState(didcomm_1.CredentialState.OfferReceived);
         this.assertOnlyIndyFormat(credentialFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         if (!credentialRecord.connectionId) {
             throw new core_1.CredoError(`No connectionId found for credential record '${credentialRecord.id}'. Connection-less issuance does not support negotiation.`);
         }
@@ -489,18 +490,22 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             })
             : undefined;
         // Create message
-        const message = new messages_1.V1ProposeCredentialMessage(Object.assign(Object.assign({}, indyCredentialProposal), { credentialPreview: credentialProposal, comment }));
+        const message = new messages_1.V1ProposeCredentialMessage({
+            ...indyCredentialProposal,
+            credentialPreview: credentialProposal,
+            comment,
+        });
         message.setThread({ threadId: credentialRecord.threadId, parentThreadId: credentialRecord.parentThreadId });
         await didCommMessageRepository.saveOrUpdateAgentMessage(agentContext, {
             agentMessage: message,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
             associatedRecordId: credentialRecord.id,
         });
         // Update record
-        credentialRecord.credentialAttributes = (_a = message.credentialPreview) === null || _a === void 0 ? void 0 : _a.attributes;
-        credentialRecord.linkedAttachments = linkedAttachments === null || linkedAttachments === void 0 ? void 0 : linkedAttachments.map((attachment) => attachment.attachment);
-        credentialRecord.autoAcceptCredential = autoAcceptCredential !== null && autoAcceptCredential !== void 0 ? autoAcceptCredential : credentialRecord.autoAcceptCredential;
-        await this.updateState(agentContext, credentialRecord, core_1.CredentialState.ProposalSent);
+        credentialRecord.credentialAttributes = message.credentialPreview?.attributes;
+        credentialRecord.linkedAttachments = linkedAttachments?.map((attachment) => attachment.attachment);
+        credentialRecord.autoAcceptCredential = autoAcceptCredential ?? credentialRecord.autoAcceptCredential;
+        await this.updateState(agentContext, credentialRecord, didcomm_1.CredentialState.ProposalSent);
         return { credentialRecord, message };
     }
     /**
@@ -512,32 +517,32 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     }
     async processRequest(messageContext) {
         const { message: requestMessage, connection, agentContext } = messageContext;
-        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);
         agentContext.config.logger.debug(`Processing credential request with id ${requestMessage.id}`);
         const credentialRecord = await this.getByProperties(messageContext.agentContext, {
             threadId: requestMessage.threadId,
-            role: core_1.CredentialRole.Issuer,
+            role: didcomm_1.CredentialRole.Issuer,
         });
         agentContext.config.logger.trace('Credential record found when processing credential request', credentialRecord);
         const proposalMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1ProposeCredentialMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const offerMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1OfferCredentialMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.OfferSent);
+        credentialRecord.assertState(didcomm_1.CredentialState.OfferSent);
         await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
-            lastReceivedMessage: proposalMessage !== null && proposalMessage !== void 0 ? proposalMessage : undefined,
-            lastSentMessage: offerMessage !== null && offerMessage !== void 0 ? offerMessage : undefined,
+            lastReceivedMessage: proposalMessage ?? undefined,
+            lastSentMessage: offerMessage ?? undefined,
             expectedConnectionId: credentialRecord.connectionId,
         });
         // This makes sure that the sender of the incoming message is authorized to do so.
@@ -545,7 +550,7 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
             await connectionService.matchIncomingMessageToRequestMessageInOutOfBandExchange(messageContext, {
                 expectedConnectionId: credentialRecord.connectionId,
             });
-            credentialRecord.connectionId = connection === null || connection === void 0 ? void 0 : connection.id;
+            credentialRecord.connectionId = connection?.id;
         }
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment) {
@@ -557,10 +562,10 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         });
         await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
             agentMessage: requestMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
             associatedRecordId: credentialRecord.id,
         });
-        await this.updateState(messageContext.agentContext, credentialRecord, core_1.CredentialState.RequestReceived);
+        await this.updateState(messageContext.agentContext, credentialRecord, didcomm_1.CredentialState.RequestReceived);
         return credentialRecord;
     }
     /**
@@ -572,19 +577,19 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     async acceptRequest(agentContext, { credentialRecord, credentialFormats, comment, autoAcceptCredential, }) {
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.RequestReceived);
+        credentialRecord.assertState(didcomm_1.CredentialState.RequestReceived);
         if (credentialFormats)
             this.assertOnlyIndyFormat(credentialFormats);
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         const offerMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1OfferCredentialMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         const requestMessage = await didCommMessageRepository.getAgentMessage(agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1RequestCredentialMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const offerAttachment = offerMessage.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
         const requestAttachment = requestMessage.getRequestAttachmentById(messages_1.INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
@@ -608,10 +613,10 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         await didCommMessageRepository.saveAgentMessage(agentContext, {
             agentMessage: issueMessage,
             associatedRecordId: credentialRecord.id,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
-        credentialRecord.autoAcceptCredential = autoAcceptCredential !== null && autoAcceptCredential !== void 0 ? autoAcceptCredential : credentialRecord.autoAcceptCredential;
-        await this.updateState(agentContext, credentialRecord, core_1.CredentialState.CredentialIssued);
+        credentialRecord.autoAcceptCredential = autoAcceptCredential ?? credentialRecord.autoAcceptCredential;
+        await this.updateState(agentContext, credentialRecord, didcomm_1.CredentialState.CredentialIssued);
         return { message: issueMessage, credentialRecord };
     }
     /**
@@ -624,28 +629,28 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     async processCredential(messageContext) {
         const { message: issueMessage, connection, agentContext } = messageContext;
         agentContext.config.logger.debug(`Processing credential with id ${issueMessage.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 credentialRecord = await this.getByProperties(messageContext.agentContext, {
             threadId: issueMessage.threadId,
-            role: core_1.CredentialRole.Holder,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.CredentialRole.Holder,
+            connectionId: connection?.id,
         });
         const requestCredentialMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1RequestCredentialMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         const offerCredentialMessage = await didCommMessageRepository.findAgentMessage(messageContext.agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1OfferCredentialMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.RequestSent);
+        credentialRecord.assertState(didcomm_1.CredentialState.RequestSent);
         await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
             lastReceivedMessage: offerCredentialMessage,
             lastSentMessage: requestCredentialMessage,
@@ -655,11 +660,11 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         if (!issueAttachment) {
             throw new core_1.CredoError('Missing indy credential attachment in processCredential');
         }
-        const requestAttachment = requestCredentialMessage === null || requestCredentialMessage === void 0 ? void 0 : requestCredentialMessage.getRequestAttachmentById(messages_1.INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+        const requestAttachment = requestCredentialMessage?.getRequestAttachmentById(messages_1.INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment) {
             throw new core_1.CredoError('Missing indy credential request attachment in processCredential');
         }
-        const offerAttachment = offerCredentialMessage === null || offerCredentialMessage === void 0 ? void 0 : offerCredentialMessage.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+        const offerAttachment = offerCredentialMessage?.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
         if (!offerAttachment) {
             throw new core_1.CredoError('Missing indy credential request attachment in processCredential');
         }
@@ -671,10 +676,10 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         });
         await didCommMessageRepository.saveAgentMessage(messageContext.agentContext, {
             agentMessage: issueMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
             associatedRecordId: credentialRecord.id,
         });
-        await this.updateState(messageContext.agentContext, credentialRecord, core_1.CredentialState.CredentialReceived);
+        await this.updateState(messageContext.agentContext, credentialRecord, didcomm_1.CredentialState.CredentialReceived);
         return credentialRecord;
     }
     /**
@@ -686,14 +691,14 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
      */
     async acceptCredential(agentContext, { credentialRecord }) {
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.CredentialReceived);
+        credentialRecord.assertState(didcomm_1.CredentialState.CredentialReceived);
         // Create message
         const ackMessage = new messages_1.V1CredentialAckMessage({
-            status: core_1.AckStatus.OK,
+            status: didcomm_1.AckStatus.OK,
             threadId: credentialRecord.threadId,
         });
         ackMessage.setThread({ threadId: credentialRecord.threadId, parentThreadId: credentialRecord.parentThreadId });
-        await this.updateState(agentContext, credentialRecord, core_1.CredentialState.Done);
+        await this.updateState(agentContext, credentialRecord, didcomm_1.CredentialState.Done);
         return { message: ackMessage, credentialRecord };
     }
     /**
@@ -706,35 +711,35 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     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(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 credentialRecord = await this.getByProperties(messageContext.agentContext, {
             threadId: ackMessage.threadId,
-            role: core_1.CredentialRole.Issuer,
-            connectionId: connection === null || connection === void 0 ? void 0 : connection.id,
+            role: didcomm_1.CredentialRole.Issuer,
+            connectionId: connection?.id,
         });
         const requestCredentialMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1RequestCredentialMessage,
-            role: core_1.DidCommMessageRole.Receiver,
+            role: didcomm_1.DidCommMessageRole.Receiver,
         });
         const issueCredentialMessage = await didCommMessageRepository.getAgentMessage(messageContext.agentContext, {
             associatedRecordId: credentialRecord.id,
             messageClass: messages_1.V1IssueCredentialMessage,
-            role: core_1.DidCommMessageRole.Sender,
+            role: didcomm_1.DidCommMessageRole.Sender,
         });
         // Assert
         credentialRecord.assertProtocolVersion('v1');
-        credentialRecord.assertState(core_1.CredentialState.CredentialIssued);
+        credentialRecord.assertState(didcomm_1.CredentialState.CredentialIssued);
         await connectionService.assertConnectionOrOutOfBandExchange(messageContext, {
             lastReceivedMessage: requestCredentialMessage,
             lastSentMessage: issueCredentialMessage,
             expectedConnectionId: credentialRecord.connectionId,
         });
         // Update record
-        await this.updateState(messageContext.agentContext, credentialRecord, core_1.CredentialState.Done);
+        await this.updateState(messageContext.agentContext, credentialRecord, didcomm_1.CredentialState.Done);
         return credentialRecord;
     }
     /**
@@ -748,7 +753,7 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         const message = new messages_1.V1CredentialProblemReportMessage({
             description: {
                 en: description,
-                code: core_1.CredentialProblemReportReason.IssuanceAbandoned,
+                code: didcomm_1.CredentialProblemReportReason.IssuanceAbandoned,
             },
         });
         return { message, credentialRecord };
@@ -756,12 +761,12 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     // AUTO RESPOND METHODS
     async shouldAutoRespondToProposal(agentContext, options) {
         const { credentialRecord, proposalMessage } = options;
-        const credentialsModuleConfig = agentContext.dependencyManager.resolve(core_1.CredentialsModuleConfig);
+        const credentialsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.CredentialsModuleConfig);
         const autoAccept = (0, utils_1.composeCredentialAutoAccept)(credentialRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptCredential.Always)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptCredential.Never)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Never)
             return false;
         const offerMessage = await this.findOfferMessage(agentContext, credentialRecord.id);
         // Do not auto accept if missing properties
@@ -780,12 +785,12 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     }
     async shouldAutoRespondToOffer(agentContext, options) {
         const { credentialRecord, offerMessage } = options;
-        const credentialsModuleConfig = agentContext.dependencyManager.resolve(core_1.CredentialsModuleConfig);
+        const credentialsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.CredentialsModuleConfig);
         const autoAccept = (0, utils_1.composeCredentialAutoAccept)(credentialRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptCredential.Always)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptCredential.Never)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Never)
             return false;
         const proposalMessage = await this.findProposalMessage(agentContext, credentialRecord.id);
         // Do not auto accept if missing properties
@@ -804,12 +809,12 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     }
     async shouldAutoRespondToRequest(agentContext, options) {
         const { credentialRecord, requestMessage } = options;
-        const credentialsModuleConfig = agentContext.dependencyManager.resolve(core_1.CredentialsModuleConfig);
+        const credentialsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.CredentialsModuleConfig);
         const autoAccept = (0, utils_1.composeCredentialAutoAccept)(credentialRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptCredential.Always)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptCredential.Never)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Never)
             return false;
         const offerMessage = await this.findOfferMessage(agentContext, credentialRecord.id);
         if (!offerMessage)
@@ -826,22 +831,22 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
     }
     async shouldAutoRespondToCredential(agentContext, options) {
         const { credentialRecord, credentialMessage } = options;
-        const credentialsModuleConfig = agentContext.dependencyManager.resolve(core_1.CredentialsModuleConfig);
+        const credentialsModuleConfig = agentContext.dependencyManager.resolve(didcomm_1.CredentialsModuleConfig);
         const autoAccept = (0, utils_1.composeCredentialAutoAccept)(credentialRecord.autoAcceptCredential, credentialsModuleConfig.autoAcceptCredentials);
         // Handle always / never cases
-        if (autoAccept === core_1.AutoAcceptCredential.Always)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Always)
             return true;
-        if (autoAccept === core_1.AutoAcceptCredential.Never)
+        if (autoAccept === didcomm_1.AutoAcceptCredential.Never)
             return false;
         const requestMessage = await this.findRequestMessage(agentContext, credentialRecord.id);
         const offerMessage = await this.findOfferMessage(agentContext, credentialRecord.id);
         const credentialAttachment = credentialMessage.getCredentialAttachmentById(messages_1.INDY_CREDENTIAL_ATTACHMENT_ID);
         if (!credentialAttachment)
             return false;
-        const requestAttachment = requestMessage === null || requestMessage === void 0 ? void 0 : requestMessage.getRequestAttachmentById(messages_1.INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
+        const requestAttachment = requestMessage?.getRequestAttachmentById(messages_1.INDY_CREDENTIAL_REQUEST_ATTACHMENT_ID);
         if (!requestAttachment)
             return false;
-        const offerAttachment = offerMessage === null || offerMessage === void 0 ? void 0 : offerMessage.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
+        const offerAttachment = offerMessage?.getOfferAttachmentById(messages_1.INDY_CREDENTIAL_OFFER_ATTACHMENT_ID);
         return this.indyCredentialFormat.shouldAutoRespondToCredential(agentContext, {
             credentialRecord,
             credentialAttachment,
@@ -850,35 +855,34 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         });
     }
     async findProposalMessage(agentContext, credentialExchangeId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: credentialExchangeId,
             messageClass: messages_1.V1ProposeCredentialMessage,
         });
     }
     async findOfferMessage(agentContext, credentialExchangeId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: credentialExchangeId,
             messageClass: messages_1.V1OfferCredentialMessage,
         });
     }
     async findRequestMessage(agentContext, credentialExchangeId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: credentialExchangeId,
             messageClass: messages_1.V1RequestCredentialMessage,
         });
     }
     async findCredentialMessage(agentContext, credentialExchangeId) {
-        const didCommMessageRepository = agentContext.dependencyManager.resolve(core_1.DidCommMessageRepository);
+        const didCommMessageRepository = agentContext.dependencyManager.resolve(didcomm_1.DidCommMessageRepository);
         return await didCommMessageRepository.findAgentMessage(agentContext, {
             associatedRecordId: credentialExchangeId,
             messageClass: messages_1.V1IssueCredentialMessage,
         });
     }
     async getFormatData(agentContext, credentialExchangeId) {
-        var _a, _b, _c, _d, _e;
         // TODO: we could looking at fetching all record using a single query and then filtering based on the type of the message.
         const [proposalMessage, offerMessage, requestMessage, credentialMessage] = await Promise.all([
             this.findProposalMessage(agentContext, credentialExchangeId),
@@ -889,17 +893,17 @@ class V1CredentialProtocol extends core_1.BaseCredentialProtocol {
         const indyProposal = proposalMessage
             ? core_1.JsonTransformer.toJSON(this.rfc0592ProposalFromV1ProposeMessage(proposalMessage))
             : undefined;
-        const indyOffer = (_a = offerMessage === null || offerMessage === void 0 ? void 0 : offerMessage.indyCredentialOffer) !== null && _a !== void 0 ? _a : undefined;
-        const indyRequest = (_b = requestMessage === null || requestMessage === void 0 ? void 0 : requestMessage.indyCredentialRequest) !== null && _b !== void 0 ? _b : undefined;
-        const indyCredential = (_c = credentialMessage === null || credentialMessage === void 0 ? void 0 : credentialMessage.indyCredential) !== null && _c !== void 0 ? _c : undefined;
+        const indyOffer = offerMessage?.indyCredentialOffer ?? undefined;
+        const indyRequest = requestMessage?.indyCredentialRequest ?? undefined;
+        const indyCredential = credentialMessage?.indyCredential ?? undefined;
         return {
-            proposalAttributes: (_d = proposalMessage === null || proposalMessage === void 0 ? void 0 : proposalMessage.credentialPreview) === null || _d === void 0 ? void 0 : _d.attributes,
+            proposalAttributes: proposalMessage?.credentialPreview?.attributes,
             proposal: proposalMessage
                 ? {
                     indy: indyProposal,
                 }
                 : undefined,
-            offerAttributes: (_e = offerMessage === null || offerMessage === void 0 ? void 0 : offerMessage.credentialPreview) === null || _e === void 0 ? void 0 : _e.attributes,
+            offerAttributes: offerMessage?.credentialPreview?.attributes,
             offer: offerMessage
                 ? {
                     indy: indyOffer,