@credo-ts/didcomm 0.6.0-alpha-20250128162925

package/build/modules/message-pickup/storage/InMemoryMessagePickupRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryMessagePickupRepository.js","sourceRoot":"","sources":["../../../../src/modules/message-pickup/storage/InMemoryMessagePickupRepository.ts"],"names":[],"mappings":"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"}

package/build/modules/message-pickup/storage/MessagePickupRepository.d.ts

@@ -0,0 +1,8 @@
+import type { AddMessageOptions, GetAvailableMessageCountOptions, RemoveMessagesOptions, TakeFromQueueOptions } from './MessagePickupRepositoryOptions';
+import type { QueuedMessage } from './QueuedMessage';
+export interface MessagePickupRepository {
+    getAvailableMessageCount(options: GetAvailableMessageCountOptions): number | Promise<number>;
+    takeFromQueue(options: TakeFromQueueOptions): QueuedMessage[] | Promise<QueuedMessage[]>;
+    addMessage(options: AddMessageOptions): string | Promise<string>;
+    removeMessages(options: RemoveMessagesOptions): void | Promise<void>;
+}

package/build/modules/message-pickup/storage/MessagePickupRepository.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MessagePickupRepository.js.map

package/build/modules/message-pickup/storage/MessagePickupRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePickupRepository.js","sourceRoot":"","sources":["../../../../src/modules/message-pickup/storage/MessagePickupRepository.ts"],"names":[],"mappings":""}

package/build/modules/message-pickup/storage/MessagePickupRepositoryOptions.d.ts

@@ -0,0 +1,20 @@
+import type { EncryptedMessage } from '../../../types';
+export interface GetAvailableMessageCountOptions {
+    connectionId: string;
+    recipientDid?: string;
+}
+export interface TakeFromQueueOptions {
+    connectionId: string;
+    recipientDid?: string;
+    limit?: number;
+    deleteMessages?: boolean;
+}
+export interface AddMessageOptions {
+    connectionId: string;
+    recipientDids: string[];
+    payload: EncryptedMessage;
+}
+export interface RemoveMessagesOptions {
+    connectionId: string;
+    messageIds: string[];
+}

package/build/modules/message-pickup/storage/MessagePickupRepositoryOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MessagePickupRepositoryOptions.js.map

package/build/modules/message-pickup/storage/MessagePickupRepositoryOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagePickupRepositoryOptions.js","sourceRoot":"","sources":["../../../../src/modules/message-pickup/storage/MessagePickupRepositoryOptions.ts"],"names":[],"mappings":""}

package/build/modules/message-pickup/storage/QueuedMessage.d.ts

@@ -0,0 +1,12 @@
+import type { EncryptedMessage } from '../../../types';
+/**
+ * Basic representation of an encrypted message in a Message Pickup Queue
+ * - id: Message Pickup repository's specific queued message id (unrelated to DIDComm message id)
+ * - receivedAt: reception time (i.e. time when the message has been added to the queue)
+ * - encryptedMessage: packed message
+ */
+export type QueuedMessage = {
+    id: string;
+    receivedAt?: Date;
+    encryptedMessage: EncryptedMessage;
+};

package/build/modules/message-pickup/storage/QueuedMessage.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=QueuedMessage.js.map

package/build/modules/message-pickup/storage/QueuedMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueuedMessage.js","sourceRoot":"","sources":["../../../../src/modules/message-pickup/storage/QueuedMessage.ts"],"names":[],"mappings":""}

package/build/modules/message-pickup/storage/index.d.ts

@@ -0,0 +1,4 @@
+export * from './InMemoryMessagePickupRepository';
+export * from './MessagePickupRepository';
+export * from './MessagePickupRepositoryOptions';
+export * from './QueuedMessage';

package/build/modules/message-pickup/storage/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./InMemoryMessagePickupRepository"), exports);
+__exportStar(require("./MessagePickupRepository"), exports);
+__exportStar(require("./MessagePickupRepositoryOptions"), exports);
+__exportStar(require("./QueuedMessage"), exports);
+//# sourceMappingURL=index.js.map

package/build/modules/message-pickup/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/message-pickup/storage/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oEAAiD;AACjD,4DAAyC;AACzC,mEAAgD;AAChD,kDAA+B"}

package/build/modules/oob/OutOfBandApi.d.ts

@@ -0,0 +1,275 @@
+import type { AgentMessage } from '../../AgentMessage';
+import type { Attachment } from '../../decorators/attachment/Attachment';
+import type { Routing } from '../../models';
+import type { Query, QueryOptions } from '@credo-ts/core';
+import { AgentContext, EventEmitter, Logger } from '@credo-ts/core';
+import { MessageHandlerRegistry } from '../../MessageHandlerRegistry';
+import { MessageSender } from '../../MessageSender';
+import { DidCommDocumentService } from '../../services';
+import { ConnectionRecord, ConnectionInvitationMessage, HandshakeProtocol } from '../connections';
+import { ConnectionsApi } from '../connections/ConnectionsApi';
+import { RoutingService } from '../routing/services/RoutingService';
+import { OutOfBandService } from './OutOfBandService';
+import { OutOfBandInvitation } from './messages';
+import { OutOfBandRecord } from './repository/OutOfBandRecord';
+export interface CreateOutOfBandInvitationConfig {
+    label?: string;
+    alias?: string;
+    imageUrl?: string;
+    goalCode?: string;
+    goal?: string;
+    handshake?: boolean;
+    handshakeProtocols?: HandshakeProtocol[];
+    messages?: AgentMessage[];
+    multiUseInvitation?: boolean;
+    autoAcceptConnection?: boolean;
+    routing?: Routing;
+    appendedAttachments?: Attachment[];
+    /**
+     * Did to use in the invitation. Cannot be used in combination with `routing`.
+     */
+    invitationDid?: string;
+}
+export interface CreateLegacyInvitationConfig {
+    label?: string;
+    alias?: string;
+    imageUrl?: string;
+    multiUseInvitation?: boolean;
+    autoAcceptConnection?: boolean;
+    routing?: Routing;
+}
+interface BaseReceiveOutOfBandInvitationConfig {
+    label?: string;
+    alias?: string;
+    imageUrl?: string;
+    autoAcceptInvitation?: boolean;
+    autoAcceptConnection?: boolean;
+    reuseConnection?: boolean;
+    routing?: Routing;
+    acceptInvitationTimeoutMs?: number;
+    isImplicit?: boolean;
+    ourDid?: string;
+}
+export type ReceiveOutOfBandInvitationConfig = Omit<BaseReceiveOutOfBandInvitationConfig, 'isImplicit'>;
+export interface ReceiveOutOfBandImplicitInvitationConfig extends Omit<BaseReceiveOutOfBandInvitationConfig, 'isImplicit' | 'reuseConnection'> {
+    did: string;
+    handshakeProtocols?: HandshakeProtocol[];
+}
+export declare class OutOfBandApi {
+    private outOfBandService;
+    private routingService;
+    private connectionsApi;
+    private messageHandlerRegistry;
+    private didCommDocumentService;
+    private messageSender;
+    private eventEmitter;
+    private agentContext;
+    private logger;
+    constructor(messageHandlerRegistry: MessageHandlerRegistry, didCommDocumentService: DidCommDocumentService, outOfBandService: OutOfBandService, routingService: RoutingService, connectionsApi: ConnectionsApi, messageSender: MessageSender, eventEmitter: EventEmitter, logger: Logger, agentContext: AgentContext);
+    /**
+     * Creates an outbound out-of-band record containing out-of-band invitation message defined in
+     * Aries RFC 0434: Out-of-Band Protocol 1.1.
+     *
+     * It automatically adds all supported handshake protocols by agent to `handshake_protocols`. You
+     * can modify this by setting `handshakeProtocols` in `config` parameter. If you want to create
+     * invitation without handshake, you can set `handshake` to `false`.
+     *
+     * If `config` parameter contains `messages` it adds them to `requests~attach` attribute.
+     *
+     * Agent role: sender (inviter)
+     *
+     * @param config configuration of how out-of-band invitation should be created
+     * @returns out-of-band record
+     */
+    createInvitation(config?: CreateOutOfBandInvitationConfig): Promise<OutOfBandRecord>;
+    /**
+     * Creates an outbound out-of-band record in the same way how `createInvitation` method does it,
+     * but it also converts out-of-band invitation message to an "legacy" invitation message defined
+     * in RFC 0160: Connection Protocol and returns it together with out-of-band record.
+     *
+     * Agent role: sender (inviter)
+     *
+     * @param config configuration of how a connection invitation should be created
+     * @returns out-of-band record and connection invitation
+     */
+    createLegacyInvitation(config?: CreateLegacyInvitationConfig): Promise<{
+        outOfBandRecord: OutOfBandRecord;
+        invitation: ConnectionInvitationMessage;
+    }>;
+    createLegacyConnectionlessInvitation<Message extends AgentMessage>(config: {
+        /**
+         * @deprecated this value is not used anymore, as the legacy connection-less exchange is now
+         * integrated with the out of band protocol. The value is kept to not break the API, but will
+         * be removed in a future version, and has no effect.
+         */
+        recordId?: string;
+        message: Message;
+        domain: string;
+        routing?: Routing;
+    }): Promise<{
+        message: Message;
+        invitationUrl: string;
+        outOfBandRecord: OutOfBandRecord;
+    }>;
+    /**
+     * Parses URL, decodes invitation and calls `receiveMessage` with parsed invitation message.
+     *
+     * Agent role: receiver (invitee)
+     *
+     * @param invitationUrl url containing a base64 encoded invitation to receive
+     * @param config configuration of how out-of-band invitation should be processed
+     * @returns out-of-band record and connection record if one has been created
+     */
+    receiveInvitationFromUrl(invitationUrl: string, config?: ReceiveOutOfBandInvitationConfig): Promise<{
+        outOfBandRecord: OutOfBandRecord;
+        connectionRecord?: ConnectionRecord;
+    }>;
+    /**
+     * Parses URL containing encoded invitation and returns invitation message.
+     *
+     * Will fetch the url if the url does not contain a base64 encoded invitation.
+     *
+     * @param invitationUrl URL containing encoded invitation
+     *
+     * @returns OutOfBandInvitation
+     */
+    parseInvitation(invitationUrl: string): Promise<OutOfBandInvitation>;
+    /**
+     * Creates inbound out-of-band record and assigns out-of-band invitation message to it if the
+     * message is valid. It automatically passes out-of-band invitation for further processing to
+     * `acceptInvitation` method. If you don't want to do that you can set `autoAcceptInvitation`
+     * attribute in `config` parameter to `false` and accept the message later by calling
+     * `acceptInvitation`.
+     *
+     * It supports both OOB (Aries RFC 0434: Out-of-Band Protocol 1.1) and Connection Invitation
+     * (0160: Connection Protocol).
+     *
+     * Agent role: receiver (invitee)
+     *
+     * @param invitation either OutOfBandInvitation or ConnectionInvitationMessage
+     * @param config config for handling of invitation
+     *
+     * @returns out-of-band record and connection record if one has been created.
+     */
+    receiveInvitation(invitation: OutOfBandInvitation | ConnectionInvitationMessage, config?: ReceiveOutOfBandInvitationConfig): Promise<{
+        outOfBandRecord: OutOfBandRecord;
+        connectionRecord?: ConnectionRecord;
+    }>;
+    /**
+     * Creates inbound out-of-band record from an implicit invitation, given as a public DID the agent
+     * should be capable of resolving. It automatically passes out-of-band invitation for further
+     * processing to `acceptInvitation` method. If you don't want to do that you can set
+     * `autoAcceptInvitation` attribute in `config` parameter to `false` and accept the message later by
+     * calling `acceptInvitation`.
+     *
+     * It supports both OOB (Aries RFC 0434: Out-of-Band Protocol 1.1) and Connection Invitation
+     * (0160: Connection Protocol). Handshake protocol to be used depends on handshakeProtocols
+     * (DID Exchange by default)
+     *
+     * Agent role: receiver (invitee)
+     *
+     * @param config config for creating and handling invitation
+     *
+     * @returns out-of-band record and connection record if one has been created.
+     */
+    receiveImplicitInvitation(config: ReceiveOutOfBandImplicitInvitationConfig): Promise<{
+        outOfBandRecord: OutOfBandRecord;
+        connectionRecord?: ConnectionRecord;
+    }>;
+    /**
+     * Internal receive invitation method, for both explicit and implicit OOB invitations
+     */
+    private _receiveInvitation;
+    /**
+     * Creates a connection if the out-of-band invitation message contains `handshake_protocols`
+     * attribute, except for the case when connection already exists and `reuseConnection` is enabled.
+     *
+     * It passes first supported message from `requests~attach` attribute to the agent, except for the
+     * case reuse of connection is applied when it just sends `handshake-reuse` message to existing
+     * connection.
+     *
+     * Agent role: receiver (invitee)
+     *
+     * @param outOfBandId
+     * @param config
+     * @returns out-of-band record and connection record if one has been created.
+     */
+    acceptInvitation(outOfBandId: string, config: {
+        autoAcceptConnection?: boolean;
+        reuseConnection?: boolean;
+        label?: string;
+        alias?: string;
+        imageUrl?: string;
+        /**
+         * Routing for the exchange (either connection or connection-less exchange).
+         *
+         * If a connection is reused, the routing WILL NOT be used.
+         */
+        routing?: Routing;
+        timeoutMs?: number;
+        ourDid?: string;
+    }): Promise<{
+        outOfBandRecord: OutOfBandRecord;
+        connectionRecord: ConnectionRecord;
+    } | {
+        outOfBandRecord: OutOfBandRecord;
+        connectionRecord?: undefined;
+    }>;
+    findByReceivedInvitationId(receivedInvitationId: string): Promise<OutOfBandRecord | null>;
+    findByCreatedInvitationId(createdInvitationId: string): Promise<OutOfBandRecord | null>;
+    /**
+     * Retrieve all out of bands records
+     *
+     * @returns List containing all  out of band records
+     */
+    getAll(): Promise<OutOfBandRecord[]>;
+    /**
+     * Retrieve all out of bands records by specified query param
+     *
+     * @returns List containing all out of band records matching specified query params
+     */
+    findAllByQuery(query: Query<OutOfBandRecord>, queryOptions?: QueryOptions): Promise<OutOfBandRecord[]>;
+    /**
+     * Retrieve a out of band record by id
+     *
+     * @param outOfBandId The  out of band record id
+     * @throws {RecordNotFoundError} If no record is found
+     * @return The out of band record
+     *
+     */
+    getById(outOfBandId: string): Promise<OutOfBandRecord>;
+    /**
+     * Find an out of band record by id
+     *
+     * @param outOfBandId the  out of band record id
+     * @returns The out of band record or null if not found
+     */
+    findById(outOfBandId: string): Promise<OutOfBandRecord | null>;
+    /**
+     * Delete an out of band record by id
+     *
+     * @param outOfBandId the out of band record id
+     */
+    deleteById(outOfBandId: string): Promise<void>;
+    private assertHandshakeProtocolsSupported;
+    private areHandshakeProtocolsSupported;
+    private getSupportedHandshakeProtocols;
+    /**
+     * Get the first supported protocol based on the handshake protocols provided in the out of band
+     * invitation.
+     *
+     * Returns an enum value from {@link HandshakeProtocol} or throw an error if no protocol is supported.
+     * Minor versions are ignored when selecting a supported protocols, so if the `outOfBandInvitationSupportedProtocolsWithMinorVersion`
+     * value is `https://didcomm.org/didexchange/1.0` and the agent supports `https://didcomm.org/didexchange/1.1`
+     * this will be fine, and the returned value will be {@link HandshakeProtocol.DidExchange}.
+     */
+    private getFirstSupportedProtocol;
+    private findExistingConnection;
+    private emitWithConnection;
+    private emitWithServices;
+    private ensureParentThreadId;
+    private handleHandshakeReuse;
+    private resolveInvitationRecipientKeyFingerprints;
+    private registerMessageHandlers;
+}
+export {};