@decentrl/event-store 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @decentrl/event-store@0.1.0 build /home/runner/work/decentrl-network/decentrl-network/packages/shared-utils/event-store
+> tsc
+

package/README.md

@@ -0,0 +1,214 @@
+# @decentrl/event-store
+
+A library for event-driven storage and communication in the decentrl ecosystem. This library abstracts away the complexity of event handling, encryption, and mediator communication, allowing you to focus on business logic.
+
+## Features
+
+- **Event Publishing**: Store events locally and optionally send to recipients
+- **Event Querying**: Retrieve stored events with filtering and pagination
+- **Pending Event Processing**: Handle incoming events from other participants
+- **Automatic Encryption/Decryption**: Transparent handling of cryptographic operations
+- **Type Safety**: Full TypeScript support with generic event types
+- **Error Handling**: Consistent error handling with detailed error information
+
+## Installation
+
+```bash
+pnpm add @decentrl/event-store
+```
+
+## Basic Usage
+
+### 1. Setup Event Store
+
+```typescript
+import { DecentrlEventStore, EventStoreConfig } from '@decentrl/event-store';
+import { useIdentityStore } from './stores/identityStore';
+import { useSignedCommunicationContractsStore } from './stores/contractsStore';
+
+const eventStoreConfig: EventStoreConfig = {
+  identity: {
+    did: identity.identityDid,
+    keys: identity.getIdentityKeys(),
+    mediatorEndpoint: identity.identityMediatorEndpoint,
+    mediatorDid: identity.mediatorDid,
+  },
+  communicationContracts: () => contractsStore.getActiveContracts(),
+};
+
+const eventStore = new DecentrlEventStore(eventStoreConfig);
+```
+
+### 2. Define Event Types
+
+```typescript
+interface ChatCreateEvent {
+  type: "chat.create";
+  data: {
+    id: string;
+    participants: [string, string];
+    createdBy: string;
+    createdAt: Date;
+  };
+}
+
+interface MessageSendEvent {
+  type: "message.send";
+  data: {
+    id: string;
+    chatId: string;
+    content: string;
+    sender: string;
+    timestamp: Date;
+  };
+}
+
+type ChatEvent = ChatCreateEvent | MessageSendEvent;
+```
+
+### 3. Publish Events
+
+```typescript
+// Publish event locally and send to recipient
+await eventStore.publishEvent(chatCreateEvent, {
+  recipient: recipientDid,
+  tags: ["chat", `chat.${chatId}`, `participant.${recipientDid}`]
+});
+
+// Publish event locally only
+await eventStore.publishEvent(messageEvent, {
+  tags: [`chat.${chatId}`]
+});
+```
+
+### 4. Query Events
+
+```typescript
+// Query all chat creation events
+const chatEvents = await eventStore.queryEvents<ChatCreateEvent>({
+  tags: ["chat"]
+});
+
+// Query messages for specific chat
+const messageEvents = await eventStore.queryEvents<MessageSendEvent>({
+  tags: [`chat.${chatId}`]
+});
+
+// Query with pagination and filters
+const events = await eventStore.queryEvents<ChatEvent>({
+  tags: ["chat"],
+  participantDid: "did:decentrl:participant123",
+  afterTimestamp: Date.now() - 86400000, // Last 24 hours
+  pagination: { page: 0, pageSize: 50 }
+});
+```
+
+### 5. Process Pending Events
+
+```typescript
+// Process all pending events from known contacts
+const newEvents = await eventStore.processPendingEvents<ChatEvent>();
+
+newEvents.forEach(event => {
+  if (event.type === "chat.create") {
+    // Handle new chat
+  } else if (event.type === "message.send") {
+    // Handle new message
+  }
+});
+```
+
+## API Reference
+
+### DecentrlEventStore
+
+#### `publishEvent<T>(event: T, options: PublishOptions): Promise<void>`
+
+Publishes an event, storing it locally and optionally sending to a recipient.
+
+**Parameters:**
+- `event`: The event object to publish
+- `options.recipient?`: DID of the recipient (if sending to someone)
+- `options.tags`: Array of tags for querying the event later
+
+#### `queryEvents<T>(options?: QueryOptions): Promise<T[]>`
+
+Queries stored events from the mediator.
+
+**Parameters:**
+- `options.tags?`: Filter by encrypted tags
+- `options.participantDid?`: Filter by participant DID
+- `options.afterTimestamp?`: Filter events after timestamp
+- `options.beforeTimestamp?`: Filter events before timestamp
+- `options.pagination?`: Pagination options
+
+#### `processPendingEvents<T>(): Promise<T[]>`
+
+Processes pending events from other participants and stores them locally.
+
+**Returns:** Array of new events that were processed
+
+## Error Handling
+
+The library provides structured error handling with the `EventStoreError` class:
+
+```typescript
+import { EventStoreError } from '@decentrl/event-store';
+
+try {
+  await eventStore.publishEvent(event, options);
+} catch (error) {
+  if (error instanceof EventStoreError) {
+    console.error(`Event store error [${error.code}]:`, error.message);
+    console.error('Details:', error.details);
+  }
+}
+```
+
+## Benefits Over Manual Implementation
+
+- **90% Less Boilerplate**: Eliminates repetitive encryption, command generation, and HTTP handling
+- **Consistent Error Handling**: Centralized error handling with detailed error information
+- **Type Safety**: Full TypeScript support with generic event types
+- **Testing**: Much easier to unit test business logic without infrastructure concerns
+- **Maintainability**: Clear separation between business logic and infrastructure
+
+## Example: Before vs After
+
+**Before (with manual implementation):**
+```typescript
+// 140+ lines of infrastructure code for sending a message
+sendMessage: async (chatId: string, content: string) => {
+  // Identity validation...
+  // Contract lookup...
+  // Encryption key derivation...
+  // Event encryption for recipient...
+  // Command generation...
+  // HTTP request...
+  // Self-encryption...
+  // Tag generation...
+  // Local storage command...
+  // Another HTTP request...
+  // Error handling...
+}
+```
+
+**After (with event store):**
+```typescript
+// ~15 lines focused on business logic
+sendMessage: async (chatId: string, content: string) => {
+  const message = { id: uuid(), chatId, content, sender: userDid, timestamp: new Date() };
+  const event = { type: "message.send", data: message };
+  
+  await eventStore.publishEvent(event, {
+    recipient: recipientDid,
+    tags: [`chat.${chatId}`]
+  });
+  
+  addMessageToState(message);
+}
+```
+
+## Integration with Zustand Stores
+
+See `example-integration.ts` for a complete example of how to refactor an existing Zustand store to use the event store library.

package/dist/event-store.d.ts

@@ -0,0 +1,64 @@
+import { type EventStoreConfig, type PaginatedResult, type PublishOptions, type QueryOptions } from './types';
+export declare class DecentrlEventStore {
+    private config;
+    constructor(config: EventStoreConfig);
+    /**
+     * Publish an event - stores locally and optionally sends to recipient
+     */
+    publishEvent<T>(event: T, options: PublishOptions): Promise<void>;
+    /**
+     * Query stored events from mediator
+     */
+    queryEvents<T>(options?: QueryOptions): Promise<PaginatedResult<T>>;
+    /**
+     * Process pending events from other participants
+     */
+    processPendingEvents<T>(): Promise<T[]>;
+    /**
+     * Process pre-fetched pending events (e.g. from WebSocket push).
+     * Same logic as processPendingEvents but skips the HTTP query.
+     */
+    processPreFetchedPendingEvents<T>(rawEvents: Array<{
+        id: string;
+        sender_did: string;
+        payload: string;
+    }>): Promise<T[]>;
+    /**
+     * Update event tags on the mediator (idempotent replace).
+     */
+    updateEventTags(events: Array<{
+        eventId: string;
+        encryptedTags: string[];
+    }>): Promise<void>;
+    /**
+     * Query events that haven't been processed by the app yet.
+     * Returns mediator event IDs alongside decrypted data for tag updates.
+     */
+    queryUnprocessedEvents<T>(pagination?: {
+        page: number;
+        pageSize: number;
+    }): Promise<PaginatedResult<T & {
+        _mediatorEventId?: string;
+    }>>;
+    /**
+     * Shared logic: filter by known senders, decrypt, store locally, acknowledge.
+     */
+    private decryptStoreAndAck;
+    /**
+     * Send event to recipient via two-way private channel
+     */
+    private sendToRecipient;
+    /**
+     * Store event locally with encrypted tags
+     */
+    private storeLocally;
+    /**
+     * Store received event with appropriate tags
+     */
+    private storeReceivedEvent;
+    /**
+     * Acknowledge processed pending events
+     */
+    private acknowledgePendingEvents;
+}
+//# sourceMappingURL=event-store.d.ts.map

package/dist/event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-store.d.ts","sourceRoot":"","sources":["../src/event-store.ts"],"names":[],"mappings":"AAmBA,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,MAAM,SAAS,CAAC;AAQjB,qBAAa,kBAAkB;IAClB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,gBAAgB;IAE5C;;OAEG;IACG,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBvE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IA2E7E;;OAEG;IACG,oBAAoB,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;IAiD7C;;;OAGG;IACG,8BAA8B,CAAC,CAAC,EACrC,SAAS,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,GACnE,OAAO,CAAC,CAAC,EAAE,CAAC;IAgBf;;OAEG;IACG,eAAe,CACpB,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC;IAoBhB;;;OAGG;IACG,sBAAsB,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE;QAC5C,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,GAAG;QAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAkE/D;;OAEG;YACW,kBAAkB;IA8EhC;;OAEG;YACW,eAAe;IAkD7B;;OAEG;YACW,YAAY;IA2C1B;;OAEG;YACW,kBAAkB;IAyChC;;OAEG;YACW,wBAAwB;CAmBtC"}

package/dist/event-store.js

@@ -0,0 +1,355 @@
+import { base64Decode, decryptString, encryptString, generateEncryptedTag, multibaseDecode, signJsonObject, verifyJsonSignature, } from '@decentrl/crypto';
+import { generateDirectAuthenticatedMediatorCommand, generateTwoWayPrivateMediatorCommand, } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/command.service';
+import axiosModule from 'axios';
+import { EventStoreError, } from './types';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const axios = {
+    post: (url, data) => axiosModule.post(url, data, { timeout: DEFAULT_TIMEOUT_MS }),
+};
+export class DecentrlEventStore {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Publish an event - stores locally and optionally sends to recipient
+     */
+    async publishEvent(event, options) {
+        try {
+            // 1. Handle recipient delivery (if specified)
+            if (options.recipient) {
+                await this.sendToRecipient(event, options.recipient);
+            }
+            // 2. Store locally for own queries (skip for ephemeral events)
+            if (!options.ephemeral) {
+                await this.storeLocally(event, options.tags, options.recipient);
+            }
+        }
+        catch (error) {
+            throw new EventStoreError(`Failed to publish event: ${error instanceof Error ? error.message : String(error)}`, 'PUBLISH_FAILED', { event, options, error });
+        }
+    }
+    /**
+     * Query stored events from mediator
+     */
+    async queryEvents(options = {}) {
+        try {
+            const { identity } = this.config;
+            const identityKeys = identity.keys;
+            const encryptedTags = options.tags?.map((tag) => generateEncryptedTag(identityKeys.signing.privateKey, tag));
+            const page = options.pagination?.page ?? 0;
+            const pageSize = options.pagination?.pageSize ?? 100;
+            const queryCommand = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+                type: 'QUERY_EVENTS',
+                filter: {
+                    encrypted_tags: encryptedTags,
+                    participant_did: options.participantDid,
+                    after_timestamp: options.afterTimestamp,
+                    before_timestamp: options.beforeTimestamp,
+                    unprocessed_only: options.unprocessedOnly,
+                },
+                pagination: { page, page_size: pageSize },
+            }, identityKeys);
+            const response = await axios.post(identity.mediatorEndpoint, queryCommand);
+            if (response.data.type !== 'SUCCESS') {
+                throw new EventStoreError('Query failed', 'QUERY_FAILED', response.data);
+            }
+            const storageKey = identityKeys.storageKey;
+            const data = [];
+            for (const event of response.data.payload.events) {
+                try {
+                    const decrypted = decryptString(event.payload, storageKey);
+                    data.push(JSON.parse(decrypted));
+                }
+                catch (error) {
+                    console.warn(`[EventStore] Decryption failure for event: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            return {
+                data,
+                pagination: {
+                    page: response.data.payload.pagination.page,
+                    pageSize: response.data.payload.pagination.page_size,
+                    total: response.data.payload.pagination.total,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof EventStoreError) {
+                throw error;
+            }
+            throw new EventStoreError(`Failed to query events: ${error instanceof Error ? error.message : String(error)}`, 'QUERY_FAILED', { options, error });
+        }
+    }
+    /**
+     * Process pending events from other participants
+     */
+    async processPendingEvents() {
+        try {
+            const { identity, communicationContracts } = this.config;
+            const activeContracts = communicationContracts();
+            if (activeContracts.length === 0) {
+                return [];
+            }
+            // Query pending events
+            const queryCommand = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+                type: 'QUERY_PENDING_EVENTS',
+                filter: {},
+                pagination: { page: 0, page_size: 100 },
+            }, identity.keys);
+            const response = await axios.post(identity.mediatorEndpoint, queryCommand);
+            if (response.data.type !== 'SUCCESS') {
+                throw new EventStoreError('Failed to query pending events', 'PENDING_QUERY_FAILED', response.data);
+            }
+            return await this.decryptStoreAndAck(response.data.payload.pending_events);
+        }
+        catch (error) {
+            if (error instanceof EventStoreError) {
+                throw error;
+            }
+            throw new EventStoreError(`Failed to process pending events: ${error instanceof Error ? error.message : String(error)}`, 'PENDING_PROCESS_FAILED', { error });
+        }
+    }
+    /**
+     * Process pre-fetched pending events (e.g. from WebSocket push).
+     * Same logic as processPendingEvents but skips the HTTP query.
+     */
+    async processPreFetchedPendingEvents(rawEvents) {
+        try {
+            return await this.decryptStoreAndAck(rawEvents);
+        }
+        catch (error) {
+            if (error instanceof EventStoreError) {
+                throw error;
+            }
+            throw new EventStoreError(`Failed to process pre-fetched pending events: ${error instanceof Error ? error.message : String(error)}`, 'PENDING_PROCESS_FAILED', { error });
+        }
+    }
+    /**
+     * Update event tags on the mediator (idempotent replace).
+     */
+    async updateEventTags(events) {
+        const { identity } = this.config;
+        const command = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+            type: 'UPDATE_EVENT_TAGS',
+            events: events.map((e) => ({
+                event_id: e.eventId,
+                encrypted_tags: e.encryptedTags,
+            })),
+        }, identity.keys);
+        await axios.post(identity.mediatorEndpoint, command);
+    }
+    /**
+     * Query events that haven't been processed by the app yet.
+     * Returns mediator event IDs alongside decrypted data for tag updates.
+     */
+    async queryUnprocessedEvents(pagination) {
+        try {
+            const { identity } = this.config;
+            const identityKeys = identity.keys;
+            const page = pagination?.page ?? 0;
+            const pageSize = pagination?.pageSize ?? 100;
+            const queryCommand = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+                type: 'QUERY_EVENTS',
+                filter: { unprocessed_only: true },
+                pagination: { page, page_size: pageSize },
+            }, identityKeys);
+            const response = await axios.post(identity.mediatorEndpoint, queryCommand);
+            if (response.data.type !== 'SUCCESS') {
+                throw new EventStoreError('Query failed', 'QUERY_FAILED', response.data);
+            }
+            const storageKey = identityKeys.storageKey;
+            const data = [];
+            for (const event of response.data.payload.events) {
+                try {
+                    const decrypted = decryptString(event.payload, storageKey);
+                    const parsed = JSON.parse(decrypted);
+                    parsed._mediatorEventId = event.id;
+                    data.push(parsed);
+                }
+                catch (error) {
+                    console.warn(`[EventStore] Decryption failure for event: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            return {
+                data,
+                pagination: {
+                    page: response.data.payload.pagination.page,
+                    pageSize: response.data.payload.pagination.page_size,
+                    total: response.data.payload.pagination.total,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof EventStoreError) {
+                throw error;
+            }
+            throw new EventStoreError(`Failed to query unprocessed events: ${error instanceof Error ? error.message : String(error)}`, 'QUERY_FAILED', { error });
+        }
+    }
+    /**
+     * Shared logic: filter by known senders, decrypt, store locally, acknowledge.
+     */
+    async decryptStoreAndAck(pendingEvents) {
+        const { communicationContracts } = this.config;
+        const activeContracts = communicationContracts();
+        if (activeContracts.length === 0) {
+            return [];
+        }
+        const knownSenders = new Set(activeContracts.map((c) => c.participantDid));
+        const filtered = pendingEvents.filter((event) => knownSenders.has(event.sender_did));
+        const processedEvents = [];
+        const ackEventIds = [];
+        for (const pendingEvent of filtered) {
+            try {
+                const matchingContracts = activeContracts
+                    .filter((c) => c.participantDid === pendingEvent.sender_did && c.rootSecret)
+                    .sort((a, b) => b.signedCommunicationContract.communication_contract.expires_at -
+                    a.signedCommunicationContract.communication_contract.expires_at);
+                let decrypted = null;
+                let contract = null;
+                for (const candidate of matchingContracts) {
+                    try {
+                        decrypted = decryptString(pendingEvent.payload, base64Decode(candidate.rootSecret));
+                        contract = candidate;
+                        break;
+                    }
+                    catch { }
+                }
+                if (!decrypted || !contract) {
+                    console.warn(`[EventStore] No contract could decrypt event ${pendingEvent.id}`);
+                    continue;
+                }
+                this.config.onContractUsed?.(contract.id, pendingEvent.sender_did);
+                const envelope = JSON.parse(decrypted);
+                const senderSigningKey = extractSigningKeyFromDid(pendingEvent.sender_did);
+                if (senderSigningKey && envelope.signature) {
+                    const { signature, ...envelopeData } = envelope;
+                    const isValid = verifyJsonSignature(envelopeData, signature, senderSigningKey);
+                    if (!isValid) {
+                        console.warn(`Invalid signature on event ${pendingEvent.id}, skipping`);
+                        continue;
+                    }
+                }
+                const event = JSON.parse(envelope.event);
+                if (!event?.meta?.ephemeral) {
+                    await this.storeReceivedEvent(event, pendingEvent.sender_did, contract.id);
+                }
+                processedEvents.push(event);
+                ackEventIds.push(pendingEvent.id);
+            }
+            catch (error) {
+                console.warn(`Failed to process pending event ${pendingEvent.id}:`, error);
+            }
+        }
+        if (ackEventIds.length > 0) {
+            await this.acknowledgePendingEvents(ackEventIds);
+        }
+        return processedEvents;
+    }
+    /**
+     * Send event to recipient via two-way private channel
+     */
+    async sendToRecipient(event, recipientDid) {
+        const { identity, communicationContracts } = this.config;
+        const contract = communicationContracts()
+            .filter((c) => c.participantDid === recipientDid && c.rootSecret && c.signedCommunicationContract)
+            .sort((a, b) => b.signedCommunicationContract.communication_contract.expires_at -
+            a.signedCommunicationContract.communication_contract.expires_at)[0];
+        if (!contract) {
+            throw new EventStoreError(`No communication contract found with ${recipientDid}`, 'CONTRACT_NOT_FOUND', { recipientDid });
+        }
+        const rootSecret = base64Decode(contract.rootSecret);
+        const timestamp = Math.floor(Date.now() / 1000);
+        const envelopeData = {
+            contract_id: contract.id,
+            event: JSON.stringify(event),
+            timestamp,
+        };
+        const signature = signJsonObject(envelopeData, identity.keys.signing.privateKey);
+        const envelope = {
+            ...envelopeData,
+            signature,
+        };
+        const encryptedPayload = encryptString(JSON.stringify(envelope), rootSecret);
+        const twoWayPrivateCommand = generateTwoWayPrivateMediatorCommand(identity.did, `${identity.did}#signing`, recipientDid, encryptedPayload, identity.keys);
+        await axios.post(identity.mediatorEndpoint, twoWayPrivateCommand);
+    }
+    /**
+     * Store event locally with encrypted tags
+     */
+    async storeLocally(event, tags, recipientDid) {
+        const { identity, communicationContracts } = this.config;
+        const storageKey = identity.keys.storageKey;
+        const encryptedEventForSelf = encryptString(JSON.stringify(event), storageKey);
+        const encryptedTags = tags.map((tag) => generateEncryptedTag(identity.keys.signing.privateKey, tag));
+        let contractId;
+        if (recipientDid) {
+            const contract = communicationContracts().find((c) => c.participantDid === recipientDid);
+            contractId = contract?.id;
+        }
+        const saveEventCommand = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+            type: 'SAVE_EVENTS',
+            events: [
+                {
+                    sender_did: identity.did,
+                    recipient_did: recipientDid || identity.did,
+                    contract_id: contractId,
+                    payload: encryptedEventForSelf,
+                    timestamp: Math.floor(Date.now() / 1000),
+                    encrypted_tags: encryptedTags,
+                },
+            ],
+        }, identity.keys);
+        await axios.post(identity.mediatorEndpoint, saveEventCommand);
+    }
+    /**
+     * Store received event with appropriate tags
+     */
+    async storeReceivedEvent(event, senderDid, contractId) {
+        const { identity } = this.config;
+        const storageKey = identity.keys.storageKey;
+        const encryptedEventForSelf = encryptString(JSON.stringify(event), storageKey);
+        const participantTag = generateEncryptedTag(identity.keys.signing.privateKey, `participant.${senderDid}`);
+        const saveEventCommand = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+            type: 'SAVE_EVENTS',
+            events: [
+                {
+                    sender_did: senderDid,
+                    recipient_did: identity.did,
+                    contract_id: contractId,
+                    payload: encryptedEventForSelf,
+                    timestamp: Math.floor(Date.now() / 1000),
+                    encrypted_tags: [participantTag],
+                },
+            ],
+        }, identity.keys);
+        await axios.post(identity.mediatorEndpoint, saveEventCommand);
+    }
+    /**
+     * Acknowledge processed pending events
+     */
+    async acknowledgePendingEvents(eventIds) {
+        const { identity } = this.config;
+        const ackCommand = generateDirectAuthenticatedMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+            type: 'ACKNOWLEDGE_PENDING_EVENTS',
+            event_ids: eventIds,
+        }, identity.keys);
+        await axios.post(identity.mediatorEndpoint, ackCommand);
+    }
+}
+const extractSigningKeyFromDid = (did) => {
+    if (!did.startsWith('did:decentrl:')) {
+        return null;
+    }
+    const parts = did.replace('did:decentrl:', '').split(':');
+    if (parts.length !== 4) {
+        return null;
+    }
+    try {
+        return multibaseDecode(parts[1]);
+    }
+    catch {
+        return null;
+    }
+};

package/dist/event-store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-store.test.d.ts.map

package/dist/event-store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-store.test.d.ts","sourceRoot":"","sources":["../src/event-store.test.ts"],"names":[],"mappings":""}