@credo-ts/askar-to-drizzle-storage-migration 0.6.0-pr-2392-20251010173905 → 0.6.0-pr-2454-20251015095608

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

@@ -1,202 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,355 +0,0 @@
-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;
-  }
-});