@credo-ts/askar-to-drizzle-storage-migration 0.6.0-alpha-20251010154241 → 0.6.0-alpha-20251010171953

package/build/packages/didcomm/src/DidCommMessageReceiver.mjs

@@ -0,0 +1,202 @@
+import { __decorateMetadata } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.mjs";
+import { canHandleMessageType, parseMessageType, replaceLegacyDidSovPrefixOnMessage } from "./util/messageType.mjs";
+import { DidCommMessage } from "./DidCommMessage.mjs";
+import { DidCommProblemReportMessage } from "./messages/problem-reports/DidCommProblemReportMessage.mjs";
+import { DidCommProblemReportError } from "./errors/problem-reports/DidCommProblemReportError.mjs";
+import "./errors/index.mjs";
+import "./messages/index.mjs";
+import { DidCommProblemReportReason } from "./models/problem-reports/DidCommProblemReportReason.mjs";
+import { DidCommInboundMessageContext } from "./models/DidCommInboundMessageContext.mjs";
+import { DidCommOutboundMessageContext } from "./models/DidCommOutboundMessageContext.mjs";
+import "./models/index.mjs";
+import { isValidJweStructure } from "./util/JWE.mjs";
+import { DidCommTransportService } from "./DidCommTransportService.mjs";
+import { __decorateParam } from "../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateParam.mjs";
+import { DidCommConnectionService } from "./modules/connections/services/DidCommConnectionService.mjs";
+import { DidCommEnvelopeService } from "./DidCommEnvelopeService.mjs";
+import { DidCommMessageSender } from "./DidCommMessageSender.mjs";
+import "./modules/connections/services/index.mjs";
+import { DidCommMessageHandlerRegistry } from "./DidCommMessageHandlerRegistry.mjs";
+import { DidCommDispatcher } from "./DidCommDispatcher.mjs";
+import { CredoError, InjectionSymbols, JsonTransformer, inject, injectable } from "@credo-ts/core";
+
+//#region ../didcomm/src/DidCommMessageReceiver.ts
+var _ref, _ref2, _ref3, _ref4, _ref5, _ref6;
+let DidCommMessageReceiver = class DidCommMessageReceiver$1 {
+	constructor(envelopeService, transportService, messageSender, connectionService, dispatcher, messageHandlerRegistry, agentContextProvider, logger) {
+		this._inboundTransports = [];
+		this.envelopeService = envelopeService;
+		this.transportService = transportService;
+		this.messageSender = messageSender;
+		this.connectionService = connectionService;
+		this.dispatcher = dispatcher;
+		this.messageHandlerRegistry = messageHandlerRegistry;
+		this.agentContextProvider = agentContextProvider;
+		this.logger = logger;
+		this._inboundTransports = [];
+	}
+	get inboundTransports() {
+		return this._inboundTransports;
+	}
+	registerInboundTransport(inboundTransport) {
+		this._inboundTransports.push(inboundTransport);
+	}
+	async unregisterInboundTransport(inboundTransport) {
+		this._inboundTransports = this._inboundTransports.filter((transport) => transport !== inboundTransport);
+		await inboundTransport.stop();
+	}
+	/**
+	* Receive and handle an inbound DIDComm message. It will determine the agent context, decrypt the message, transform it
+	* to it's corresponding message class and finally dispatch it to the dispatcher.
+	*
+	* @param inboundMessage the message to receive and handle
+	*/
+	async receiveMessage(inboundMessage, { session, connection, contextCorrelationId, receivedAt } = {}) {
+		this.logger.debug("Agent received message");
+		const agentContext = await this.agentContextProvider.getContextForInboundMessage(inboundMessage, { contextCorrelationId });
+		try {
+			if (this.isEncryptedMessage(inboundMessage)) await this.receiveEncryptedMessage(agentContext, inboundMessage, session, receivedAt);
+			else if (this.isPlaintextMessage(inboundMessage)) await this.receivePlaintextMessage(agentContext, inboundMessage, connection, receivedAt);
+			else throw new CredoError("Unable to parse incoming message: unrecognized format");
+		} finally {
+			await agentContext.endSession();
+		}
+	}
+	async receivePlaintextMessage(agentContext, plaintextMessage, connection, receivedAt) {
+		const messageContext = new DidCommInboundMessageContext(await this.transformAndValidate(agentContext, plaintextMessage), {
+			connection,
+			agentContext,
+			receivedAt
+		});
+		await this.dispatcher.dispatch(messageContext);
+	}
+	async receiveEncryptedMessage(agentContext, encryptedMessage, session, receivedAt) {
+		const decryptedMessage = await this.decryptMessage(agentContext, encryptedMessage);
+		const { plaintextMessage, senderKey, recipientKey } = decryptedMessage;
+		this.logger.info(`Received message with type '${plaintextMessage["@type"]}', recipient key ${recipientKey?.fingerprint} and sender key ${senderKey?.fingerprint}`, plaintextMessage);
+		const connection = await this.findConnectionByMessageKeys(agentContext, decryptedMessage);
+		const message = await this.transformAndValidate(agentContext, plaintextMessage, connection);
+		const messageContext = new DidCommInboundMessageContext(message, {
+			connection: connection?.isReady ? connection : void 0,
+			senderKey,
+			recipientKey,
+			agentContext,
+			receivedAt,
+			encryptedMessage
+		});
+		if (senderKey && recipientKey && message.hasAnyReturnRoute() && session) {
+			this.logger.debug(`Storing session for inbound message '${message.id}'`);
+			session.keys = {
+				recipientKeys: [senderKey],
+				routingKeys: [],
+				senderKey: recipientKey
+			};
+			session.inboundMessage = message;
+			session.connectionId = connection?.id;
+			messageContext.sessionId = session.id;
+			this.transportService.saveSession(session);
+		} else if (session) await session.close();
+		await this.dispatcher.dispatch(messageContext);
+	}
+	/**
+	* Decrypt a message using the envelope service.
+	*
+	* @param message the received inbound message to decrypt
+	*/
+	async decryptMessage(agentContext, message) {
+		try {
+			return await this.envelopeService.unpackMessage(agentContext, message);
+		} catch (error) {
+			this.logger.error("Error while decrypting message", {
+				error,
+				encryptedMessage: message,
+				errorMessage: error instanceof Error ? error.message : error
+			});
+			throw error;
+		}
+	}
+	isPlaintextMessage(message) {
+		if (typeof message !== "object" || message == null) return false;
+		return "@type" in message;
+	}
+	isEncryptedMessage(message) {
+		return isValidJweStructure(message);
+	}
+	async transformAndValidate(agentContext, plaintextMessage, connection) {
+		let message;
+		try {
+			message = await this.transformMessage(plaintextMessage);
+		} catch (error) {
+			if (connection) await this.sendProblemReportMessage(agentContext, error.message, connection, plaintextMessage);
+			throw error;
+		}
+		return message;
+	}
+	async findConnectionByMessageKeys(agentContext, { recipientKey, senderKey }) {
+		if (!recipientKey || !senderKey) return null;
+		return this.connectionService.findByKeys(agentContext, {
+			senderKey,
+			recipientKey
+		});
+	}
+	/**
+	* Transform an plaintext DIDComm message into it's corresponding message class. Will look at all message types in the registered handlers.
+	*
+	* @param message the plaintext message for which to transform the message in to a class instance
+	*/
+	async transformMessage(message) {
+		replaceLegacyDidSovPrefixOnMessage(message);
+		const messageType = message["@type"];
+		const MessageClass = this.messageHandlerRegistry.getMessageClassForMessageType(messageType) ?? DidCommMessage;
+		let messageTransformed;
+		try {
+			messageTransformed = JsonTransformer.fromJSON(message, MessageClass);
+		} catch (error) {
+			this.logger.error(`Error validating message ${message["@type"]}`, {
+				errors: error,
+				message: JSON.stringify(message)
+			});
+			throw new DidCommProblemReportError(`Error validating message ${message["@type"]}`, { problemCode: DidCommProblemReportReason.MessageParseFailure });
+		}
+		return messageTransformed;
+	}
+	/**
+	* Send the problem report message (https://didcomm.org/notification/1.0/problem-report) to the recipient.
+	* @param message error message to send
+	* @param connection connection to send the message to
+	* @param plaintextMessage received inbound message
+	*/
+	async sendProblemReportMessage(agentContext, message, connection, plaintextMessage) {
+		if (canHandleMessageType(DidCommProblemReportMessage, parseMessageType(plaintextMessage["@type"]))) throw new CredoError(`Not sending problem report in response to problem report: ${message}`);
+		const problemReportMessage = new DidCommProblemReportMessage({ description: {
+			en: message,
+			code: DidCommProblemReportReason.MessageParseFailure
+		} });
+		problemReportMessage.setThread({ parentThreadId: plaintextMessage["@id"] });
+		const outboundMessageContext = new DidCommOutboundMessageContext(problemReportMessage, {
+			agentContext,
+			connection
+		});
+		if (outboundMessageContext) await this.messageSender.sendMessage(outboundMessageContext);
+	}
+};
+DidCommMessageReceiver = __decorate([
+	injectable(),
+	__decorateParam(6, inject(InjectionSymbols.AgentContextProvider)),
+	__decorateParam(7, inject(InjectionSymbols.Logger)),
+	__decorateMetadata("design:paramtypes", [
+		typeof (_ref = typeof DidCommEnvelopeService !== "undefined" && DidCommEnvelopeService) === "function" ? _ref : Object,
+		typeof (_ref2 = typeof DidCommTransportService !== "undefined" && DidCommTransportService) === "function" ? _ref2 : Object,
+		typeof (_ref3 = typeof DidCommMessageSender !== "undefined" && DidCommMessageSender) === "function" ? _ref3 : Object,
+		typeof (_ref4 = typeof DidCommConnectionService !== "undefined" && DidCommConnectionService) === "function" ? _ref4 : Object,
+		typeof (_ref5 = typeof DidCommDispatcher !== "undefined" && DidCommDispatcher) === "function" ? _ref5 : Object,
+		typeof (_ref6 = typeof DidCommMessageHandlerRegistry !== "undefined" && DidCommMessageHandlerRegistry) === "function" ? _ref6 : Object,
+		Object,
+		Object
+	])
+], DidCommMessageReceiver);
+
+//#endregion
+export { DidCommMessageReceiver };
+//# sourceMappingURL=DidCommMessageReceiver.mjs.map

package/build/packages/didcomm/src/DidCommMessageReceiver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DidCommMessageReceiver.mjs","names":["DidCommMessageReceiver","agentContextProvider: AgentContextProvider","logger: Logger","message: DidCommMessage","messageTransformed: DidCommMessage"],"sources":["../../../../../didcomm/src/DidCommMessageReceiver.ts"],"sourcesContent":["import type { AgentContext } from '@credo-ts/core'\nimport type { DecryptedDidCommMessageContext } from './DidCommEnvelopeService'\nimport type { DidCommTransportSession } from './DidCommTransportService'\nimport type { DidCommConnectionRecord } from './modules/connections/repository'\nimport type { DidCommInboundTransport } from './transport'\nimport type { DidCommEncryptedMessage, DidCommPlaintextMessage } from './types'\n\nimport {\n  type AgentContextProvider,\n  CredoError,\n  InjectionSymbols,\n  JsonTransformer,\n  type Logger,\n  inject,\n  injectable,\n} from '@credo-ts/core'\n\nimport { DidCommDispatcher } from './DidCommDispatcher'\nimport { DidCommEnvelopeService } from './DidCommEnvelopeService'\nimport { DidCommMessage } from './DidCommMessage'\nimport { DidCommMessageHandlerRegistry } from './DidCommMessageHandlerRegistry'\nimport { DidCommMessageSender } from './DidCommMessageSender'\nimport { DidCommTransportService } from './DidCommTransportService'\nimport { DidCommProblemReportError } from './errors'\nimport { DidCommProblemReportMessage } from './messages'\nimport { DidCommInboundMessageContext, DidCommOutboundMessageContext, DidCommProblemReportReason } from './models'\nimport { DidCommConnectionService } from './modules/connections/services'\nimport { isValidJweStructure } from './util/JWE'\nimport { canHandleMessageType, parseMessageType, replaceLegacyDidSovPrefixOnMessage } from './util/messageType'\n\n@injectable()\nexport class DidCommMessageReceiver {\n  private envelopeService: DidCommEnvelopeService\n  private transportService: DidCommTransportService\n  private messageSender: DidCommMessageSender\n  private dispatcher: DidCommDispatcher\n  private logger: Logger\n  private connectionService: DidCommConnectionService\n  private messageHandlerRegistry: DidCommMessageHandlerRegistry\n  private agentContextProvider: AgentContextProvider\n  private _inboundTransports: DidCommInboundTransport[] = []\n\n  public constructor(\n    envelopeService: DidCommEnvelopeService,\n    transportService: DidCommTransportService,\n    messageSender: DidCommMessageSender,\n    connectionService: DidCommConnectionService,\n    dispatcher: DidCommDispatcher,\n    messageHandlerRegistry: DidCommMessageHandlerRegistry,\n    @inject(InjectionSymbols.AgentContextProvider) agentContextProvider: AgentContextProvider,\n    @inject(InjectionSymbols.Logger) logger: Logger\n  ) {\n    this.envelopeService = envelopeService\n    this.transportService = transportService\n    this.messageSender = messageSender\n    this.connectionService = connectionService\n    this.dispatcher = dispatcher\n    this.messageHandlerRegistry = messageHandlerRegistry\n    this.agentContextProvider = agentContextProvider\n    this.logger = logger\n    this._inboundTransports = []\n  }\n\n  public get inboundTransports() {\n    return this._inboundTransports\n  }\n\n  public registerInboundTransport(inboundTransport: DidCommInboundTransport) {\n    this._inboundTransports.push(inboundTransport)\n  }\n\n  public async unregisterInboundTransport(inboundTransport: DidCommInboundTransport) {\n    this._inboundTransports = this._inboundTransports.filter((transport) => transport !== inboundTransport)\n    await inboundTransport.stop()\n  }\n\n  /**\n   * Receive and handle an inbound DIDComm message. It will determine the agent context, decrypt the message, transform it\n   * to it's corresponding message class and finally dispatch it to the dispatcher.\n   *\n   * @param inboundMessage the message to receive and handle\n   */\n  public async receiveMessage(\n    inboundMessage: unknown,\n    {\n      session,\n      connection,\n      contextCorrelationId,\n      receivedAt,\n    }: {\n      session?: DidCommTransportSession\n      connection?: DidCommConnectionRecord\n      contextCorrelationId?: string\n      receivedAt?: Date\n    } = {}\n  ) {\n    this.logger.debug('Agent received message')\n\n    // Find agent context for the inbound message\n    const agentContext = await this.agentContextProvider.getContextForInboundMessage(inboundMessage, {\n      contextCorrelationId,\n    })\n\n    try {\n      if (this.isEncryptedMessage(inboundMessage)) {\n        await this.receiveEncryptedMessage(agentContext, inboundMessage as DidCommEncryptedMessage, session, receivedAt)\n      } else if (this.isPlaintextMessage(inboundMessage)) {\n        await this.receivePlaintextMessage(agentContext, inboundMessage, connection, receivedAt)\n      } else {\n        throw new CredoError('Unable to parse incoming message: unrecognized format')\n      }\n    } finally {\n      // Always end the session for the agent context after handling the message.\n      await agentContext.endSession()\n    }\n  }\n\n  private async receivePlaintextMessage(\n    agentContext: AgentContext,\n    plaintextMessage: DidCommPlaintextMessage,\n    connection?: DidCommConnectionRecord,\n    receivedAt?: Date\n  ) {\n    const message = await this.transformAndValidate(agentContext, plaintextMessage)\n    const messageContext = new DidCommInboundMessageContext(message, { connection, agentContext, receivedAt })\n    await this.dispatcher.dispatch(messageContext)\n  }\n\n  private async receiveEncryptedMessage(\n    agentContext: AgentContext,\n    encryptedMessage: DidCommEncryptedMessage,\n    session?: DidCommTransportSession,\n    receivedAt?: Date\n  ) {\n    const decryptedMessage = await this.decryptMessage(agentContext, encryptedMessage)\n    const { plaintextMessage, senderKey, recipientKey } = decryptedMessage\n\n    this.logger.info(\n      `Received message with type '${plaintextMessage['@type']}', recipient key ${recipientKey?.fingerprint} and sender key ${senderKey?.fingerprint}`,\n      plaintextMessage\n    )\n\n    const connection = await this.findConnectionByMessageKeys(agentContext, decryptedMessage)\n\n    const message = await this.transformAndValidate(agentContext, plaintextMessage, connection)\n\n    const messageContext = new DidCommInboundMessageContext(message, {\n      // Only make the connection available in message context if the connection is ready\n      // To prevent unwanted usage of unready connections. Connections can still be retrieved from\n      // Storage if the specific protocol allows an unready connection to be used.\n      connection: connection?.isReady ? connection : undefined,\n      senderKey,\n      recipientKey,\n      agentContext,\n      receivedAt,\n      encryptedMessage,\n    })\n\n    // We want to save a session if there is a chance of returning outbound message via inbound transport.\n    // That can happen when inbound message has `return_route` set to `all` or `thread`.\n    // If `return_route` defines just `thread`, we decide later whether to use session according to outbound message `threadId`.\n    if (senderKey && recipientKey && message.hasAnyReturnRoute() && session) {\n      this.logger.debug(`Storing session for inbound message '${message.id}'`)\n      const keys = {\n        recipientKeys: [senderKey],\n        routingKeys: [],\n        senderKey: recipientKey,\n      }\n      session.keys = keys\n      session.inboundMessage = message\n      // We allow unready connections to be attached to the session as we want to be able to\n      // use return routing to make connections. This is especially useful for creating connections\n      // with mediators when you don't have a public endpoint yet.\n      session.connectionId = connection?.id\n      messageContext.sessionId = session.id\n      this.transportService.saveSession(session)\n    } else if (session) {\n      // No need to wait for session to stay open if we're not actually going to respond to the message.\n      await session.close()\n    }\n\n    await this.dispatcher.dispatch(messageContext)\n  }\n\n  /**\n   * Decrypt a message using the envelope service.\n   *\n   * @param message the received inbound message to decrypt\n   */\n  private async decryptMessage(\n    agentContext: AgentContext,\n    message: DidCommEncryptedMessage\n  ): Promise<DecryptedDidCommMessageContext> {\n    try {\n      return await this.envelopeService.unpackMessage(agentContext, message)\n    } catch (error) {\n      this.logger.error('Error while decrypting message', {\n        error,\n        encryptedMessage: message,\n        errorMessage: error instanceof Error ? error.message : error,\n      })\n      throw error\n    }\n  }\n\n  private isPlaintextMessage(message: unknown): message is DidCommPlaintextMessage {\n    if (typeof message !== 'object' || message == null) {\n      return false\n    }\n    // If the message has a @type field we assume the message is in plaintext and it is not encrypted.\n    return '@type' in message\n  }\n\n  private isEncryptedMessage(message: unknown): message is DidCommEncryptedMessage {\n    // If the message does has valid JWE structure, we can assume the message is encrypted.\n    return isValidJweStructure(message)\n  }\n\n  private async transformAndValidate(\n    agentContext: AgentContext,\n    plaintextMessage: DidCommPlaintextMessage,\n    connection?: DidCommConnectionRecord | null\n  ): Promise<DidCommMessage> {\n    let message: DidCommMessage\n    try {\n      message = await this.transformMessage(plaintextMessage)\n    } catch (error) {\n      if (connection) await this.sendProblemReportMessage(agentContext, error.message, connection, plaintextMessage)\n      throw error\n    }\n    return message\n  }\n\n  private async findConnectionByMessageKeys(\n    agentContext: AgentContext,\n    { recipientKey, senderKey }: DecryptedDidCommMessageContext\n  ): Promise<DidCommConnectionRecord | null> {\n    // We only fetch connections that are sent in AuthCrypt mode\n    if (!recipientKey || !senderKey) return null\n\n    // Try to find the did records that holds the sender and recipient keys\n    return this.connectionService.findByKeys(agentContext, {\n      senderKey,\n      recipientKey,\n    })\n  }\n\n  /**\n   * Transform an plaintext DIDComm message into it's corresponding message class. Will look at all message types in the registered handlers.\n   *\n   * @param message the plaintext message for which to transform the message in to a class instance\n   */\n  private async transformMessage(message: DidCommPlaintextMessage): Promise<DidCommMessage> {\n    // replace did:sov:BzCbsNYhMrjHiqZDTUASHg;spec prefix for message type with https://didcomm.org\n    replaceLegacyDidSovPrefixOnMessage(message)\n\n    const messageType = message['@type']\n    const MessageClass = this.messageHandlerRegistry.getMessageClassForMessageType(messageType) ?? DidCommMessage\n\n    // Cast the plain JSON object to specific instance of Message extended from DidCommMessage\n    let messageTransformed: DidCommMessage\n    try {\n      messageTransformed = JsonTransformer.fromJSON(message, MessageClass)\n    } catch (error) {\n      this.logger.error(`Error validating message ${message['@type']}`, {\n        errors: error,\n        message: JSON.stringify(message),\n      })\n      throw new DidCommProblemReportError(`Error validating message ${message['@type']}`, {\n        problemCode: DidCommProblemReportReason.MessageParseFailure,\n      })\n    }\n    return messageTransformed\n  }\n\n  /**\n   * Send the problem report message (https://didcomm.org/notification/1.0/problem-report) to the recipient.\n   * @param message error message to send\n   * @param connection connection to send the message to\n   * @param plaintextMessage received inbound message\n   */\n  private async sendProblemReportMessage(\n    agentContext: AgentContext,\n    message: string,\n    connection: DidCommConnectionRecord,\n    plaintextMessage: DidCommPlaintextMessage\n  ) {\n    const messageType = parseMessageType(plaintextMessage['@type'])\n    if (canHandleMessageType(DidCommProblemReportMessage, messageType)) {\n      throw new CredoError(`Not sending problem report in response to problem report: ${message}`)\n    }\n    const problemReportMessage = new DidCommProblemReportMessage({\n      description: {\n        en: message,\n        code: DidCommProblemReportReason.MessageParseFailure,\n      },\n    })\n    problemReportMessage.setThread({\n      parentThreadId: plaintextMessage['@id'],\n    })\n    const outboundMessageContext = new DidCommOutboundMessageContext(problemReportMessage, { agentContext, connection })\n    if (outboundMessageContext) {\n      await this.messageSender.sendMessage(outboundMessageContext)\n    }\n  }\n}\n"],"mappings":"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"}

package/build/packages/didcomm/src/DidCommMessageSender.js

@@ -0,0 +1,355 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_decorateMetadata = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorateMetadata.js');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.94.0/helpers/decorate.js');
+const require_TransportDecorator = require('./decorators/transport/TransportDecorator.js');
+const require_MessageSendingError = require('./errors/MessageSendingError.js');
+require('./errors/index.js');
+const require_DidCommOutboundMessageContext = require('./models/DidCommOutboundMessageContext.js');
+const require_DidCommOutboundMessageSendStatus = require('./models/DidCommOutboundMessageSendStatus.js');
+require('./models/index.js');
+const require_constants = require('./constants.js');
+const require_DidCommEvents = require('./DidCommEvents.js');
+const require_DidCommModuleConfig = require('./DidCommModuleConfig.js');
+const require_DidCommTransportService = require('./DidCommTransportService.js');
+const require_DidCommDocumentService = require('./services/DidCommDocumentService.js');
+const require_DidCommEnvelopeService = require('./DidCommEnvelopeService.js');
+let __credo_ts_core = require("@credo-ts/core");
+__credo_ts_core = require_rolldown_runtime.__toESM(__credo_ts_core);
+
+//#region ../didcomm/src/DidCommMessageSender.ts
+var _ref, _ref2, _ref3, _ref4, _ref5;
+let DidCommMessageSender = class DidCommMessageSender$1 {
+	constructor(envelopeService, transportService, didCommModuleConfig, didCommDocumentService, eventEmitter) {
+		this._outboundTransports = [];
+		this.envelopeService = envelopeService;
+		this.transportService = transportService;
+		this.queueTransportRepository = didCommModuleConfig.queueTransportRepository;
+		this.didCommDocumentService = didCommDocumentService;
+		this.eventEmitter = eventEmitter;
+		this._outboundTransports = [];
+	}
+	get outboundTransports() {
+		return this._outboundTransports;
+	}
+	registerOutboundTransport(outboundTransport) {
+		this._outboundTransports.push(outboundTransport);
+	}
+	async unregisterOutboundTransport(outboundTransport) {
+		this._outboundTransports = this.outboundTransports.filter((transport) => transport !== outboundTransport);
+		await outboundTransport.stop();
+	}
+	async packMessage(agentContext, { keys, message, endpoint }) {
+		return {
+			payload: await this.envelopeService.packMessage(agentContext, message, keys),
+			responseRequested: message.hasAnyReturnRoute(),
+			endpoint
+		};
+	}
+	async sendMessageToSession(agentContext, session, message) {
+		agentContext.config.logger.debug(`Packing message and sending it via existing session ${session.type}...`);
+		if (!session.keys) throw new __credo_ts_core.CredoError(`There are no keys for the given ${session.type} transport session.`);
+		const encryptedMessage = await this.envelopeService.packMessage(agentContext, message, session.keys);
+		agentContext.config.logger.debug("Sending message");
+		await session.send(agentContext, encryptedMessage);
+	}
+	async sendPackage(agentContext, { connection, encryptedMessage, recipientKey, options }) {
+		const errors = [];
+		const session = this.transportService.findSessionByConnectionId(connection.id);
+		if (session?.inboundMessage?.hasReturnRouting()) try {
+			await session.send(agentContext, encryptedMessage);
+			return;
+		} catch (error) {
+			errors.push(error);
+			agentContext.config.logger.debug(`Sending packed message via session failed with error: ${error.message}.`, error);
+		}
+		const { services, queueService } = await this.retrieveServicesByConnection(agentContext, connection, options?.transportPriority);
+		if (this.outboundTransports.length === 0 && !queueService) throw new __credo_ts_core.CredoError("Agent has no outbound transport!");
+		for await (const service of services) {
+			agentContext.config.logger.debug("Sending outbound message to service:", { service });
+			try {
+				const protocolScheme = __credo_ts_core.utils.getProtocolScheme(service.serviceEndpoint);
+				for (const transport of this.outboundTransports) if (transport.supportedSchemes.includes(protocolScheme)) {
+					await transport.sendMessage({
+						payload: encryptedMessage,
+						endpoint: service.serviceEndpoint,
+						connectionId: connection.id
+					});
+					break;
+				}
+				return;
+			} catch (error) {
+				agentContext.config.logger.debug(`Sending outbound message to service with id ${service.id} failed with the following error:`, {
+					message: error.message,
+					error
+				});
+			}
+		}
+		if (queueService) {
+			agentContext.config.logger.debug(`Queue packed message for connection ${connection.id} (${connection.theirLabel})`);
+			await this.queueTransportRepository.addMessage(agentContext, {
+				connectionId: connection.id,
+				recipientDids: [(0, __credo_ts_core.verkeyToDidKey)(recipientKey)],
+				payload: encryptedMessage
+			});
+			return;
+		}
+		agentContext.config.logger.error(`Message is undeliverable to connection ${connection.id} (${connection.theirLabel})`, {
+			message: encryptedMessage,
+			errors,
+			connection
+		});
+		throw new __credo_ts_core.CredoError(`Message is undeliverable to connection ${connection.id} (${connection.theirLabel})`);
+	}
+	async sendMessage(outboundMessageContext, options) {
+		const { agentContext, connection, outOfBand, message } = outboundMessageContext;
+		const errors = [];
+		if (outboundMessageContext.isOutboundServiceMessage()) return this.sendMessageToService(outboundMessageContext);
+		if (!connection) {
+			agentContext.config.logger.error("Outbound message has no associated connection");
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.Undeliverable);
+			throw new require_MessageSendingError.MessageSendingError("Outbound message has no associated connection", { outboundMessageContext });
+		}
+		agentContext.config.logger.debug("Send outbound message", {
+			message,
+			connectionId: connection.id
+		});
+		const session = this.findSessionForOutboundContext(outboundMessageContext);
+		if (session) {
+			agentContext.config.logger.debug(`Found session with return routing for message '${message.id}' (connection '${connection.id}'`);
+			try {
+				await this.sendMessageToSession(agentContext, session, message);
+				this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.SentToSession);
+				return;
+			} catch (error) {
+				errors.push(error);
+				agentContext.config.logger.debug(`Sending an outbound message via session failed with error: ${error.message}.`, error);
+			}
+		}
+		let services = [];
+		let queueService;
+		try {
+			({services, queueService} = await this.retrieveServicesByConnection(agentContext, connection, options?.transportPriority, outOfBand));
+		} catch (error) {
+			agentContext.config.logger.error(`Unable to retrieve services for connection '${connection.id}. ${error.message}`);
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.Undeliverable);
+			throw new require_MessageSendingError.MessageSendingError(`Unable to retrieve services for connection '${connection.id}`, {
+				outboundMessageContext,
+				cause: error
+			});
+		}
+		if (!connection.did) {
+			agentContext.config.logger.error(`Unable to send message using connection '${connection.id}' that doesn't have a did`);
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.Undeliverable);
+			throw new require_MessageSendingError.MessageSendingError(`Unable to send message using connection '${connection.id}' that doesn't have a did`, { outboundMessageContext });
+		}
+		const { didDocument, keys } = await agentContext.resolve(__credo_ts_core.DidsApi).resolveCreatedDidDocumentWithKeys(connection.did).catch((error) => {
+			agentContext.config.logger.error(`Unable to send message using connection '${connection.id}', unable to resolve did`, { error });
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.Undeliverable);
+			throw new require_MessageSendingError.MessageSendingError(`Unable to send message using connection '${connection.id}'. Unble to resolve did`, {
+				outboundMessageContext,
+				cause: error
+			});
+		});
+		const authentication = didDocument.authentication?.map((a) => {
+			const verificationMethod = typeof a === "string" ? didDocument.dereferenceVerificationMethod(a) : a;
+			const publicJwk = (0, __credo_ts_core.getPublicJwkFromVerificationMethod)(verificationMethod);
+			const kmsKeyId = keys?.find((key) => verificationMethod.id.endsWith(key.didDocumentRelativeKeyId))?.kmsKeyId;
+			publicJwk.keyId = kmsKeyId ?? publicJwk.legacyKeyId;
+			return {
+				verificationMethod,
+				publicJwk,
+				kmsKeyId
+			};
+		}).filter((v) => v.publicJwk.is(__credo_ts_core.Kms.Ed25519PublicJwk));
+		const senderVerificationMethod = authentication?.find((a) => a.kmsKeyId !== void 0) ?? authentication?.[0];
+		if (!senderVerificationMethod) throw new require_MessageSendingError.MessageSendingError(`Unable to determine sender key for did ${connection.did}, no available Ed25519 keys`, { outboundMessageContext });
+		const shouldAddReturnRoute = message.transport?.returnRoute === void 0 && !this.transportService.hasInboundEndpoint(didDocument);
+		for await (const service of services) try {
+			await this.sendToService(new require_DidCommOutboundMessageContext.DidCommOutboundMessageContext(message, {
+				agentContext,
+				serviceParams: {
+					service,
+					senderKey: senderVerificationMethod.publicJwk,
+					returnRoute: shouldAddReturnRoute
+				},
+				connection
+			}));
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.SentToTransport);
+			return;
+		} catch (error) {
+			errors.push(error);
+			agentContext.config.logger.debug(`Sending outbound message to service with id ${service.id} failed with the following error:`, {
+				message: error.message,
+				error
+			});
+		}
+		if (queueService && message.allowQueueTransport) {
+			agentContext.config.logger.debug(`Queue message for connection ${connection.id} (${connection.theirLabel})`);
+			const keys$1 = {
+				recipientKeys: queueService.recipientKeys,
+				routingKeys: queueService.routingKeys,
+				senderKey: senderVerificationMethod.publicJwk
+			};
+			const encryptedMessage = await this.envelopeService.packMessage(agentContext, message, keys$1);
+			await this.queueTransportRepository.addMessage(agentContext, {
+				connectionId: connection.id,
+				recipientDids: keys$1.recipientKeys.map((item) => new __credo_ts_core.DidKey(item).did),
+				payload: encryptedMessage
+			});
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.QueuedForPickup);
+			return;
+		}
+		agentContext.config.logger.error(`Message is undeliverable to connection ${connection.id} (${connection.theirLabel})`, {
+			message,
+			errors,
+			connection
+		});
+		this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.Undeliverable);
+		throw new require_MessageSendingError.MessageSendingError(`Message is undeliverable to connection ${connection.id} (${connection.theirLabel}). \n\nReasons:\n\t- ${errors.map((e) => e.message).join("\n	-")}`, { outboundMessageContext });
+	}
+	async sendMessageToService(outboundMessageContext) {
+		const session = this.findSessionForOutboundContext(outboundMessageContext);
+		if (session) {
+			outboundMessageContext.agentContext.config.logger.debug(`Found session with return routing for message '${outboundMessageContext.message.id}'`);
+			try {
+				await this.sendMessageToSession(outboundMessageContext.agentContext, session, outboundMessageContext.message);
+				this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.SentToSession);
+				return;
+			} catch (error) {
+				outboundMessageContext.agentContext.config.logger.debug(`Sending an outbound message via session failed with error: ${error.message}.`, error);
+			}
+		}
+		try {
+			await this.sendToService(outboundMessageContext);
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.SentToTransport);
+		} catch (error) {
+			outboundMessageContext.agentContext.config.logger.error(`Message is undeliverable to service with id ${outboundMessageContext.serviceParams?.service.id}: ${error.message}`, {
+				message: outboundMessageContext.message,
+				error
+			});
+			this.emitMessageSentEvent(outboundMessageContext, require_DidCommOutboundMessageSendStatus.OutboundMessageSendStatus.Undeliverable);
+			throw new require_MessageSendingError.MessageSendingError(`Message is undeliverable to service with id ${outboundMessageContext.serviceParams?.service.id}: ${error.message}`, { outboundMessageContext });
+		}
+	}
+	async sendToService(outboundMessageContext) {
+		const { agentContext, message, serviceParams, connection } = outboundMessageContext;
+		if (!serviceParams) throw new __credo_ts_core.CredoError("No service parameters found in outbound message context");
+		const { service, senderKey, returnRoute } = serviceParams;
+		if (this.outboundTransports.length === 0) throw new __credo_ts_core.CredoError("Agent has no outbound transport!");
+		agentContext.config.logger.debug("Sending outbound message to service:", {
+			messageId: message.id,
+			service: {
+				...service,
+				recipientKeys: "omitted...",
+				routingKeys: "omitted..."
+			}
+		});
+		const keys = {
+			recipientKeys: service.recipientKeys,
+			routingKeys: service.routingKeys,
+			senderKey
+		};
+		if (returnRoute) message.setReturnRouting(require_TransportDecorator.ReturnRouteTypes.all);
+		try {
+			__credo_ts_core.MessageValidator.validateSync(message);
+		} catch (error) {
+			agentContext.config.logger.error(`Aborting sending outbound message ${message.type} to ${service.serviceEndpoint}. Message validation failed`, {
+				errors: error,
+				message: message.toJSON()
+			});
+			throw error;
+		}
+		const outboundPackage = await this.packMessage(agentContext, {
+			message,
+			keys,
+			endpoint: service.serviceEndpoint
+		});
+		outboundPackage.endpoint = service.serviceEndpoint;
+		outboundPackage.connectionId = connection?.id;
+		for (const transport of this.outboundTransports) {
+			const protocolScheme = __credo_ts_core.utils.getProtocolScheme(service.serviceEndpoint);
+			if (!protocolScheme) agentContext.config.logger.warn("Service does not have a protocol scheme.");
+			else if (transport.supportedSchemes.includes(protocolScheme)) {
+				await transport.sendMessage(outboundPackage);
+				return;
+			}
+		}
+		throw new require_MessageSendingError.MessageSendingError(`Unable to send message to service: ${service.serviceEndpoint}`, { outboundMessageContext });
+	}
+	findSessionForOutboundContext(outboundContext) {
+		let session = void 0;
+		const sessionId = outboundContext.sessionId ?? outboundContext.inboundMessageContext?.sessionId;
+		if (sessionId) session = this.transportService.findSessionById(sessionId);
+		if (!session && outboundContext.connection?.id) session = this.transportService.findSessionByConnectionId(outboundContext.connection.id);
+		return session?.inboundMessage?.hasAnyReturnRoute() ? session : null;
+	}
+	async retrieveServicesByConnection(agentContext, connection, transportPriority, outOfBand) {
+		agentContext.config.logger.debug(`Retrieving services for connection '${connection.id}' (${connection.theirLabel})`, {
+			transportPriority,
+			connection
+		});
+		let didCommServices = [];
+		if (connection.theirDid) {
+			agentContext.config.logger.debug(`Resolving services for connection theirDid ${connection.theirDid}.`);
+			didCommServices = await this.didCommDocumentService.resolveServicesFromDid(agentContext, connection.theirDid);
+		} else if (outOfBand) {
+			agentContext.config.logger.debug(`Resolving services from out-of-band record ${outOfBand.id}.`);
+			if (connection.isRequester) for (const service of outOfBand.outOfBandInvitation.getServices()) if (typeof service === "string") {
+				agentContext.config.logger.debug(`Resolving services for did ${service}.`);
+				didCommServices.push(...await this.didCommDocumentService.resolveServicesFromDid(agentContext, service));
+			} else didCommServices.push({
+				id: service.id,
+				recipientKeys: service.recipientKeys.map(__credo_ts_core.didKeyToEd25519PublicJwk),
+				routingKeys: service.routingKeys?.map(__credo_ts_core.didKeyToEd25519PublicJwk) || [],
+				serviceEndpoint: service.serviceEndpoint
+			});
+		}
+		let services = didCommServices.filter((s) => !isDidCommTransportQueue(s.serviceEndpoint));
+		const queueService = didCommServices.find((s) => isDidCommTransportQueue(s.serviceEndpoint));
+		if (transportPriority?.restrictive) services = services.filter((service) => {
+			const serviceSchema = __credo_ts_core.utils.getProtocolScheme(service.serviceEndpoint);
+			return transportPriority.schemes.includes(serviceSchema);
+		});
+		if (transportPriority?.schemes) services = services.sort((a, b) => {
+			const aScheme = __credo_ts_core.utils.getProtocolScheme(a.serviceEndpoint);
+			const bScheme = __credo_ts_core.utils.getProtocolScheme(b.serviceEndpoint);
+			return transportPriority?.schemes.indexOf(aScheme) - transportPriority?.schemes.indexOf(bScheme);
+		});
+		agentContext.config.logger.debug(`Retrieved ${services.length} services for message to connection '${connection.id}'(${connection.theirLabel})'`, {
+			hasQueueService: queueService !== void 0,
+			transportPriority
+		});
+		return {
+			services,
+			queueService
+		};
+	}
+	emitMessageSentEvent(outboundMessageContext, status) {
+		const { agentContext } = outboundMessageContext;
+		this.eventEmitter.emit(agentContext, {
+			type: require_DidCommEvents.DidCommEventTypes.DidCommMessageSent,
+			payload: {
+				message: outboundMessageContext,
+				status
+			}
+		});
+	}
+};
+DidCommMessageSender = require_decorate.__decorate([(0, __credo_ts_core.injectable)(), require_decorateMetadata.__decorateMetadata("design:paramtypes", [
+	typeof (_ref = typeof require_DidCommEnvelopeService.DidCommEnvelopeService !== "undefined" && require_DidCommEnvelopeService.DidCommEnvelopeService) === "function" ? _ref : Object,
+	typeof (_ref2 = typeof require_DidCommTransportService.DidCommTransportService !== "undefined" && require_DidCommTransportService.DidCommTransportService) === "function" ? _ref2 : Object,
+	typeof (_ref3 = typeof require_DidCommModuleConfig.DidCommModuleConfig !== "undefined" && require_DidCommModuleConfig.DidCommModuleConfig) === "function" ? _ref3 : Object,
+	typeof (_ref4 = typeof require_DidCommDocumentService.DidCommDocumentService !== "undefined" && require_DidCommDocumentService.DidCommDocumentService) === "function" ? _ref4 : Object,
+	typeof (_ref5 = typeof __credo_ts_core.EventEmitter !== "undefined" && __credo_ts_core.EventEmitter) === "function" ? _ref5 : Object
+])], DidCommMessageSender);
+function isDidCommTransportQueue(serviceEndpoint) {
+	return serviceEndpoint === require_constants.DID_COMM_TRANSPORT_QUEUE;
+}
+
+//#endregion
+Object.defineProperty(exports, 'DidCommMessageSender', {
+  enumerable: true,
+  get: function () {
+    return DidCommMessageSender;
+  }
+});