@decentrl/event-store 0.0.7 → 0.0.8

package/dist/event-store.d.ts

@@ -1,4 +1,4 @@
-import { type EventStoreConfig, type PaginatedResult, type PublishOptions, type QueryOptions } from './types';
+import { type EventStoreConfig, type PaginatedResult, type PublicEventResult, type PublicPublishOptions, type PublicQueryOptions, type PublishOptions, type QueryOptions } from './types';
 export declare class DecentrlEventStore {
     private config;
     constructor(config: EventStoreConfig);
@@ -40,6 +40,20 @@ export declare class DecentrlEventStore {
     }): Promise<PaginatedResult<T & {
         _mediatorEventId?: string;
     }>>;
+    /**
+     * Publish a public (unencrypted, signed) event to the mediator.
+     */
+    publishPublicEvent(event: string, options: PublicPublishOptions): Promise<{
+        publicEventId: string;
+    }>;
+    /**
+     * Delete a public event from the mediator.
+     */
+    deletePublicEvent(publicEventId: string): Promise<void>;
+    /**
+     * Fetch public events from any publisher (no identity needed).
+     */
+    static fetchPublicEvents(options: PublicQueryOptions): Promise<PaginatedResult<PublicEventResult>>;
     /**
      * Shared logic: filter by known senders, decrypt, store locally, acknowledge.
      */

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

@@ -1 +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"}
+{"version":3,"file":"event-store.d.ts","sourceRoot":"","sources":["../src/event-store.ts"],"names":[],"mappings":"AAqBA,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,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;IACG,kBAAkB,CACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,oBAAoB,GAC3B,OAAO,CAAC;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IAwCrC;;OAEG;IACG,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B7D;;OAEG;WACU,iBAAiB,CAC7B,OAAO,EAAE,kBAAkB,GACzB,OAAO,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC;IA2D9C;;OAEG;YACW,kBAAkB;IAgFhC;;OAEG;YACW,eAAe;IAkD7B;;OAEG;YACW,YAAY;IA2C1B;;OAEG;YACW,kBAAkB;IAyChC;;OAEG;YACW,wBAAwB;CAmBtC"}

package/dist/event-store.js

@@ -1,5 +1,6 @@
 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 { generateOneWayPublicMediatorCommand } from '@decentrl/identity/communication-channels/mediator/one-way-public/command/command.service';
 import axiosModule from 'axios';
 import { EventStoreError, } from './types';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -187,6 +188,88 @@ export class DecentrlEventStore {
             throw new EventStoreError(`Failed to query unprocessed events: ${error instanceof Error ? error.message : String(error)}`, 'QUERY_FAILED', { error });
         }
     }
+    /**
+     * Publish a public (unencrypted, signed) event to the mediator.
+     */
+    async publishPublicEvent(event, options) {
+        const { identity } = this.config;
+        const timestamp = Math.floor(Date.now() / 1000);
+        const signedData = {
+            channel_id: options.channelId,
+            event,
+            tags: options.tags,
+            timestamp,
+        };
+        const eventSignature = signJsonObject(signedData, identity.keys.signing.privateKey);
+        const command = generateOneWayPublicMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+            type: 'PUBLISH_PUBLIC_EVENT',
+            channel_id: options.channelId,
+            event,
+            tags: options.tags,
+            timestamp,
+            event_signature: eventSignature,
+        }, identity.keys);
+        const response = await axios.post(identity.mediatorEndpoint, command);
+        if (response.data.type !== 'SUCCESS') {
+            throw new EventStoreError('Failed to publish public event', 'PUBLISH_FAILED', response.data);
+        }
+        return { publicEventId: response.data.public_event_id };
+    }
+    /**
+     * Delete a public event from the mediator.
+     */
+    async deletePublicEvent(publicEventId) {
+        const { identity } = this.config;
+        const command = generateOneWayPublicMediatorCommand(identity.did, `${identity.did}#signing`, identity.mediatorDid, {
+            type: 'DELETE_PUBLIC_EVENT',
+            public_event_id: publicEventId,
+        }, identity.keys);
+        const response = await axios.post(identity.mediatorEndpoint, command);
+        if (response.data.type === 'ERROR') {
+            throw new EventStoreError(`Failed to delete public event: ${response.data.code}`, 'DELETE_FAILED', response.data);
+        }
+    }
+    /**
+     * Fetch public events from any publisher (no identity needed).
+     */
+    static async fetchPublicEvents(options) {
+        const params = new URLSearchParams();
+        if (options.channelId) {
+            params.set('channel_id', options.channelId);
+        }
+        if (options.tags?.length) {
+            params.set('tags', options.tags.join(','));
+        }
+        if (options.afterTimestamp) {
+            params.set('after', String(options.afterTimestamp));
+        }
+        if (options.beforeTimestamp) {
+            params.set('before', String(options.beforeTimestamp));
+        }
+        if (options.pagination) {
+            params.set('page', String(options.pagination.page));
+            params.set('page_size', String(options.pagination.pageSize));
+        }
+        const url = `${options.mediatorEndpoint}/public/${options.publisherDid}?${params.toString()}`;
+        const response = await axiosModule.get(url, {
+            timeout: DEFAULT_TIMEOUT_MS,
+        });
+        return {
+            data: response.data.events.map((e) => ({
+                id: e.id,
+                channelId: e.channel_id,
+                event: e.event,
+                tags: e.tags,
+                timestamp: e.timestamp,
+                eventSignature: e.event_signature,
+            })),
+            pagination: {
+                page: response.data.pagination.page,
+                pageSize: response.data.pagination.page_size,
+                total: response.data.pagination.total,
+            },
+        };
+    }
     /**
      * Shared logic: filter by known senders, decrypt, store locally, acknowledge.
      */
@@ -232,7 +315,8 @@ export class DecentrlEventStore {
                     }
                 }
                 const event = JSON.parse(envelope.event);
-                if (!event?.meta?.ephemeral) {
+                const eventWithMeta = event;
+                if (!eventWithMeta?.meta?.ephemeral) {
                     await this.storeReceivedEvent(event, pendingEvent.sender_did, contract.id);
                 }
                 processedEvents.push(event);

package/dist/event-store.test.js

@@ -13,12 +13,31 @@ vi.mock('@decentrl/identity/communication-channels/mediator/direct-authenticated
     generateDirectAuthenticatedMediatorCommand: vi.fn(() => ({ mock: 'command' })),
     generateTwoWayPrivateMediatorCommand: vi.fn(() => ({ mock: 'two-way-command' })),
 }));
-vi.mock('axios', () => ({
-    default: {
-        post: vi.fn(async () => ({ data: { type: 'SUCCESS', payload: {} } })),
-    },
+vi.mock('@decentrl/identity/communication-channels/mediator/one-way-public/command/command.service', () => ({
+    generateOneWayPublicMediatorCommand: vi.fn(() => ({ mock: 'one-way-public-command' })),
 }));
+vi.mock('axios', () => {
+    const post = vi.fn(async () => ({ data: { type: 'SUCCESS', payload: {} } }));
+    const get = vi.fn(async () => ({
+        data: {
+            publisher_did: 'did:decentrl:bob',
+            events: [
+                {
+                    id: 'pub-evt-1',
+                    channel_id: 'blog',
+                    event: '{"type":"blog.post","data":{"title":"Hello"}}',
+                    tags: ['blog'],
+                    timestamp: 1710000000,
+                    event_signature: 'sig-1',
+                },
+            ],
+            pagination: { page: 0, page_size: 20, total: 1 },
+        },
+    }));
+    return { default: { post, get }, post, get };
+});
 import { decryptString } from '@decentrl/crypto';
+import axios from 'axios';
 import { DecentrlEventStore } from './event-store.js';
 const makeContract = (opts) => ({
     id: opts.id,
@@ -249,25 +268,135 @@ describe('DecentrlEventStore', () => {
             vi.mocked(decryptString).mockReset();
         });
         it('stores locally for non-ephemeral events', async () => {
-            const axios = await import('axios');
+            const axiosModule = await import('axios');
             const eventStore = new DecentrlEventStore({
                 identity: mockIdentity,
                 communicationContracts: () => [],
             });
             await eventStore.publishEvent({ type: 'test' }, { tags: ['tag1'] });
             // Should have called axios.post for SAVE_EVENTS
-            expect(axios.default.post).toHaveBeenCalled();
+            expect(axiosModule.default.post).toHaveBeenCalled();
         });
         it('skips local storage for ephemeral events without recipient', async () => {
-            const axios = await import('axios');
-            vi.mocked(axios.default.post).mockClear();
+            const axiosModule = await import('axios');
+            vi.mocked(axiosModule.default.post).mockClear();
             const eventStore = new DecentrlEventStore({
                 identity: mockIdentity,
                 communicationContracts: () => [],
             });
             await eventStore.publishEvent({ type: 'test' }, { tags: ['tag1'], ephemeral: true });
             // Should NOT have called axios.post since no recipient and ephemeral
-            expect(axios.default.post).not.toHaveBeenCalled();
+            expect(axiosModule.default.post).not.toHaveBeenCalled();
+        });
+    });
+    describe('publishPublicEvent', () => {
+        beforeEach(() => {
+            vi.mocked(axios.post).mockResolvedValue({
+                data: { type: 'SUCCESS', public_event_id: 'pub-123' },
+            });
+        });
+        it('signs the event data and sends a ONE_WAY_PUBLIC command', async () => {
+            const { signJsonObject } = await import('@decentrl/crypto');
+            const { generateOneWayPublicMediatorCommand } = await import('@decentrl/identity/communication-channels/mediator/one-way-public/command/command.service');
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [],
+            });
+            const result = await eventStore.publishPublicEvent('{"type":"test","data":{}}', {
+                channelId: 'blog',
+                tags: ['blog', 'test'],
+            });
+            expect(result.publicEventId).toBe('pub-123');
+            expect(signJsonObject).toHaveBeenCalled();
+            expect(generateOneWayPublicMediatorCommand).toHaveBeenCalled();
+            expect(axios.post).toHaveBeenCalledWith('http://mediator', { mock: 'one-way-public-command' }, { timeout: 30000 });
+        });
+        it('uses seconds for timestamp', async () => {
+            const { signJsonObject } = await import('@decentrl/crypto');
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [],
+            });
+            await eventStore.publishPublicEvent('test', { channelId: 'blog', tags: [] });
+            const signedData = vi.mocked(signJsonObject).mock.calls[0][0];
+            // Timestamp should be in seconds (roughly current time / 1000)
+            expect(signedData.timestamp).toBeLessThan(Date.now());
+            expect(signedData.timestamp).toBeGreaterThan(Date.now() / 1000 - 10);
+        });
+        it('throws on error response', async () => {
+            vi.mocked(axios.post).mockResolvedValue({
+                data: { type: 'ERROR', code: 'INVALID_EVENT_SIGNATURE' },
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [],
+            });
+            await expect(eventStore.publishPublicEvent('test', { channelId: 'blog', tags: [] })).rejects.toThrow('Failed to publish public event');
+        });
+    });
+    describe('deletePublicEvent', () => {
+        it('sends a DELETE_PUBLIC_EVENT command', async () => {
+            vi.mocked(axios.post).mockResolvedValue({
+                data: { type: 'SUCCESS' },
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [],
+            });
+            await expect(eventStore.deletePublicEvent('pub-123')).resolves.toBeUndefined();
+            expect(axios.post).toHaveBeenCalled();
+        });
+        it('throws on error response', async () => {
+            vi.mocked(axios.post).mockResolvedValue({
+                data: { type: 'ERROR', code: 'PUBLIC_EVENT_NOT_FOUND' },
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [],
+            });
+            await expect(eventStore.deletePublicEvent('nonexistent')).rejects.toThrow('Failed to delete public event');
+        });
+    });
+    describe('fetchPublicEvents (static)', () => {
+        it('fetches events via GET without requiring identity', async () => {
+            const result = await DecentrlEventStore.fetchPublicEvents({
+                mediatorEndpoint: 'http://mediator',
+                publisherDid: 'did:decentrl:bob',
+                channelId: 'blog',
+            });
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0].id).toBe('pub-evt-1');
+            expect(result.data[0].channelId).toBe('blog');
+            expect(result.data[0].timestamp).toBe(1710000000);
+            expect(result.pagination.total).toBe(1);
+        });
+        it('passes query parameters to the GET URL', async () => {
+            vi.mocked(axios.get).mockClear();
+            await DecentrlEventStore.fetchPublicEvents({
+                mediatorEndpoint: 'http://mediator',
+                publisherDid: 'did:decentrl:bob',
+                channelId: 'blog',
+                tags: ['tag1', 'tag2'],
+                afterTimestamp: 1710000000,
+                pagination: { page: 2, pageSize: 10 },
+            });
+            const url = vi.mocked(axios.get).mock.calls[0][0];
+            expect(url).toContain('/public/did:decentrl:bob');
+            expect(url).toContain('channel_id=blog');
+            expect(url).toContain('tags=tag1%2Ctag2');
+            expect(url).toContain('after=1710000000');
+            expect(url).toContain('page=2');
+            expect(url).toContain('page_size=10');
+        });
+        it('maps snake_case response to camelCase', async () => {
+            const result = await DecentrlEventStore.fetchPublicEvents({
+                mediatorEndpoint: 'http://mediator',
+                publisherDid: 'did:decentrl:bob',
+            });
+            // Verify camelCase mapping
+            expect(result.data[0].channelId).toBe('blog');
+            expect(result.data[0].eventSignature).toBe('sig-1');
+            expect(result.pagination.pageSize).toBe(20);
         });
     });
 });

package/dist/types.d.ts

@@ -45,6 +45,32 @@ export interface PaginatedResult<T> {
     data: T[];
     pagination: PaginationMeta;
 }
+export interface PublicPublishOptions {
+    channelId: string;
+    tags: string[];
+}
+export interface PublicQueryOptions {
+    mediatorEndpoint: string;
+    publisherDid: string;
+    channelId?: string;
+    tags?: string[];
+    /** Unix timestamp in seconds */
+    afterTimestamp?: number;
+    /** Unix timestamp in seconds */
+    beforeTimestamp?: number;
+    pagination?: {
+        page: number;
+        pageSize: number;
+    };
+}
+export interface PublicEventResult {
+    id: string;
+    channelId: string;
+    event: string;
+    tags: string[];
+    timestamp: number;
+    eventSignature: string;
+}
 export declare class EventStoreError extends Error {
     code: string;
     details?: unknown | undefined;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yEAAyE,CAAC;AAE3H,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE;QACT,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,oBAAoB,CAAC;QAC3B,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,sBAAsB,EAAE,MAAM,oBAAoB,EAAE,CAAC;IACrD,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;CACtE;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,2BAA2B,EAAE,2BAA2B,CAAC;IACzD,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IACjC,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,UAAU,EAAE,cAAc,CAAC;CAC3B;AAED,qBAAa,eAAgB,SAAQ,KAAK;IAGjC,IAAI,EAAE,MAAM;IACZ,OAAO,CAAC,EAAE,OAAO;gBAFxB,OAAO,EAAE,MAAM,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,YAAA;CAKzB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yEAAyE,CAAC;AAE3H,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE;QACT,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,oBAAoB,CAAC;QAC3B,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,sBAAsB,EAAE,MAAM,oBAAoB,EAAE,CAAC;IACrD,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;CACtE;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,2BAA2B,EAAE,2BAA2B,CAAC;IACzD,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IACjC,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,UAAU,EAAE,cAAc,CAAC;CAC3B;AAID,MAAM,WAAW,oBAAoB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,gCAAgC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gCAAgC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD;AAED,MAAM,WAAW,iBAAiB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,eAAgB,SAAQ,KAAK;IAGjC,IAAI,EAAE,MAAM;IACZ,OAAO,CAAC,EAAE,OAAO;gBAFxB,OAAO,EAAE,MAAM,EACR,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,YAAA;CAKzB"}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@decentrl/event-store",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Event-driven storage and communication library for decentrl",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
     "axios": "^1.6.0",
-    "@decentrl/identity": "0.0.7",
-    "@decentrl/crypto": "0.0.7"
+    "@decentrl/crypto": "0.0.8",
+    "@decentrl/identity": "0.0.8"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/event-store.test.ts

@@ -19,13 +19,37 @@ vi.mock(
 	}),
 );
 
-vi.mock('axios', () => ({
-	default: {
-		post: vi.fn(async () => ({ data: { type: 'SUCCESS', payload: {} } })),
-	},
-}));
+vi.mock(
+	'@decentrl/identity/communication-channels/mediator/one-way-public/command/command.service',
+	() => ({
+		generateOneWayPublicMediatorCommand: vi.fn(() => ({ mock: 'one-way-public-command' })),
+	}),
+);
+
+vi.mock('axios', () => {
+	const post = vi.fn(async () => ({ data: { type: 'SUCCESS', payload: {} } }));
+	const get = vi.fn(async () => ({
+		data: {
+			publisher_did: 'did:decentrl:bob',
+			events: [
+				{
+					id: 'pub-evt-1',
+					channel_id: 'blog',
+					event: '{"type":"blog.post","data":{"title":"Hello"}}',
+					tags: ['blog'],
+					timestamp: 1710000000,
+					event_signature: 'sig-1',
+				},
+			],
+			pagination: { page: 0, page_size: 20, total: 1 },
+		},
+	}));
+
+	return { default: { post, get }, post, get };
+});
 
 import { decryptString } from '@decentrl/crypto';
+import axios from 'axios';
 import { DecentrlEventStore } from './event-store.js';
 import type { StoredSignedContract } from './types.js';
 
@@ -310,7 +334,7 @@ describe('DecentrlEventStore', () => {
 		});
 
 		it('stores locally for non-ephemeral events', async () => {
-			const axios = await import('axios');
+			const axiosModule = await import('axios');
 
 			const eventStore = new DecentrlEventStore({
 				identity: mockIdentity,
@@ -320,12 +344,12 @@ describe('DecentrlEventStore', () => {
 			await eventStore.publishEvent({ type: 'test' }, { tags: ['tag1'] });
 
 			// Should have called axios.post for SAVE_EVENTS
-			expect(axios.default.post).toHaveBeenCalled();
+			expect(axiosModule.default.post).toHaveBeenCalled();
 		});
 
 		it('skips local storage for ephemeral events without recipient', async () => {
-			const axios = await import('axios');
-			vi.mocked(axios.default.post).mockClear();
+			const axiosModule = await import('axios');
+			vi.mocked(axiosModule.default.post).mockClear();
 
 			const eventStore = new DecentrlEventStore({
 				identity: mockIdentity,
@@ -335,7 +359,152 @@ describe('DecentrlEventStore', () => {
 			await eventStore.publishEvent({ type: 'test' }, { tags: ['tag1'], ephemeral: true });
 
 			// Should NOT have called axios.post since no recipient and ephemeral
-			expect(axios.default.post).not.toHaveBeenCalled();
+			expect(axiosModule.default.post).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('publishPublicEvent', () => {
+		beforeEach(() => {
+			vi.mocked(axios.post).mockResolvedValue({
+				data: { type: 'SUCCESS', public_event_id: 'pub-123' },
+			});
+		});
+
+		it('signs the event data and sends a ONE_WAY_PUBLIC command', async () => {
+			const { signJsonObject } = await import('@decentrl/crypto');
+			const { generateOneWayPublicMediatorCommand } = await import(
+				'@decentrl/identity/communication-channels/mediator/one-way-public/command/command.service'
+			);
+
+			const eventStore = new DecentrlEventStore({
+				identity: mockIdentity,
+				communicationContracts: () => [],
+			});
+
+			const result = await eventStore.publishPublicEvent('{"type":"test","data":{}}', {
+				channelId: 'blog',
+				tags: ['blog', 'test'],
+			});
+
+			expect(result.publicEventId).toBe('pub-123');
+			expect(signJsonObject).toHaveBeenCalled();
+			expect(generateOneWayPublicMediatorCommand).toHaveBeenCalled();
+			expect(axios.post).toHaveBeenCalledWith(
+				'http://mediator',
+				{ mock: 'one-way-public-command' },
+				{ timeout: 30000 },
+			);
+		});
+
+		it('uses seconds for timestamp', async () => {
+			const { signJsonObject } = await import('@decentrl/crypto');
+
+			const eventStore = new DecentrlEventStore({
+				identity: mockIdentity,
+				communicationContracts: () => [],
+			});
+
+			await eventStore.publishPublicEvent('test', { channelId: 'blog', tags: [] });
+
+			const signedData = vi.mocked(signJsonObject).mock.calls[0][0] as Record<string, unknown>;
+			// Timestamp should be in seconds (roughly current time / 1000)
+			expect(signedData.timestamp).toBeLessThan(Date.now());
+			expect(signedData.timestamp).toBeGreaterThan(Date.now() / 1000 - 10);
+		});
+
+		it('throws on error response', async () => {
+			vi.mocked(axios.post).mockResolvedValue({
+				data: { type: 'ERROR', code: 'INVALID_EVENT_SIGNATURE' },
+			});
+
+			const eventStore = new DecentrlEventStore({
+				identity: mockIdentity,
+				communicationContracts: () => [],
+			});
+
+			await expect(
+				eventStore.publishPublicEvent('test', { channelId: 'blog', tags: [] }),
+			).rejects.toThrow('Failed to publish public event');
+		});
+	});
+
+	describe('deletePublicEvent', () => {
+		it('sends a DELETE_PUBLIC_EVENT command', async () => {
+			vi.mocked(axios.post).mockResolvedValue({
+				data: { type: 'SUCCESS' },
+			});
+
+			const eventStore = new DecentrlEventStore({
+				identity: mockIdentity,
+				communicationContracts: () => [],
+			});
+
+			await expect(eventStore.deletePublicEvent('pub-123')).resolves.toBeUndefined();
+			expect(axios.post).toHaveBeenCalled();
+		});
+
+		it('throws on error response', async () => {
+			vi.mocked(axios.post).mockResolvedValue({
+				data: { type: 'ERROR', code: 'PUBLIC_EVENT_NOT_FOUND' },
+			});
+
+			const eventStore = new DecentrlEventStore({
+				identity: mockIdentity,
+				communicationContracts: () => [],
+			});
+
+			await expect(eventStore.deletePublicEvent('nonexistent')).rejects.toThrow(
+				'Failed to delete public event',
+			);
+		});
+	});
+
+	describe('fetchPublicEvents (static)', () => {
+		it('fetches events via GET without requiring identity', async () => {
+			const result = await DecentrlEventStore.fetchPublicEvents({
+				mediatorEndpoint: 'http://mediator',
+				publisherDid: 'did:decentrl:bob',
+				channelId: 'blog',
+			});
+
+			expect(result.data).toHaveLength(1);
+			expect(result.data[0].id).toBe('pub-evt-1');
+			expect(result.data[0].channelId).toBe('blog');
+			expect(result.data[0].timestamp).toBe(1710000000);
+			expect(result.pagination.total).toBe(1);
+		});
+
+		it('passes query parameters to the GET URL', async () => {
+			vi.mocked(axios.get).mockClear();
+
+			await DecentrlEventStore.fetchPublicEvents({
+				mediatorEndpoint: 'http://mediator',
+				publisherDid: 'did:decentrl:bob',
+				channelId: 'blog',
+				tags: ['tag1', 'tag2'],
+				afterTimestamp: 1710000000,
+				pagination: { page: 2, pageSize: 10 },
+			});
+
+			const url = vi.mocked(axios.get).mock.calls[0][0] as string;
+			expect(url).toContain('/public/did:decentrl:bob');
+			expect(url).toContain('channel_id=blog');
+			expect(url).toContain('tags=tag1%2Ctag2');
+			expect(url).toContain('after=1710000000');
+			expect(url).toContain('page=2');
+			expect(url).toContain('page_size=10');
+		});
+
+		it('maps snake_case response to camelCase', async () => {
+			const result = await DecentrlEventStore.fetchPublicEvents({
+				mediatorEndpoint: 'http://mediator',
+				publisherDid: 'did:decentrl:bob',
+			});
+
+			// Verify camelCase mapping
+			expect(result.data[0].channelId).toBe('blog');
+			expect(result.data[0].eventSignature).toBe('sig-1');
+			expect(result.pagination.pageSize).toBe(20);
 		});
 	});
 });

package/src/event-store.ts

@@ -16,11 +16,16 @@ import type { QueryEventsMediatorCommandResponse } from '@decentrl/identity/comm
 import type { QueryPendingEventsMediatorCommandResponse } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/query-pending-events.schema';
 import type { SaveEventsMediatorCommandResponse } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/save-events.schema';
 import type { UpdateEventTagsMediatorCommandResponse } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/update-event-tags.schema';
+import type { PublishPublicEventResponse } from '@decentrl/identity/communication-channels/mediator/one-way-public/command/command.schema';
+import { generateOneWayPublicMediatorCommand } from '@decentrl/identity/communication-channels/mediator/one-way-public/command/command.service';
 import axiosModule from 'axios';
 import {
 	type EventStoreConfig,
 	EventStoreError,
 	type PaginatedResult,
+	type PublicEventResult,
+	type PublicPublishOptions,
+	type PublicQueryOptions,
 	type PublishOptions,
 	type QueryOptions,
 } from './types';
@@ -307,6 +312,147 @@ export class DecentrlEventStore {
 		}
 	}
 
+	/**
+	 * Publish a public (unencrypted, signed) event to the mediator.
+	 */
+	async publishPublicEvent(
+		event: string,
+		options: PublicPublishOptions,
+	): Promise<{ publicEventId: string }> {
+		const { identity } = this.config;
+		const timestamp = Math.floor(Date.now() / 1000);
+
+		const signedData = {
+			channel_id: options.channelId,
+			event,
+			tags: options.tags,
+			timestamp,
+		};
+
+		const eventSignature = signJsonObject(signedData, identity.keys.signing.privateKey);
+
+		const command = generateOneWayPublicMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			identity.mediatorDid,
+			{
+				type: 'PUBLISH_PUBLIC_EVENT',
+				channel_id: options.channelId,
+				event,
+				tags: options.tags,
+				timestamp,
+				event_signature: eventSignature,
+			},
+			identity.keys,
+		);
+
+		const response = await axios.post<PublishPublicEventResponse>(
+			identity.mediatorEndpoint,
+			command,
+		);
+
+		if (response.data.type !== 'SUCCESS') {
+			throw new EventStoreError('Failed to publish public event', 'PUBLISH_FAILED', response.data);
+		}
+
+		return { publicEventId: response.data.public_event_id };
+	}
+
+	/**
+	 * Delete a public event from the mediator.
+	 */
+	async deletePublicEvent(publicEventId: string): Promise<void> {
+		const { identity } = this.config;
+
+		const command = generateOneWayPublicMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			identity.mediatorDid,
+			{
+				type: 'DELETE_PUBLIC_EVENT',
+				public_event_id: publicEventId,
+			},
+			identity.keys,
+		);
+
+		const response = await axios.post<{ type: string; code?: string }>(
+			identity.mediatorEndpoint,
+			command,
+		);
+
+		if (response.data.type === 'ERROR') {
+			throw new EventStoreError(
+				`Failed to delete public event: ${response.data.code}`,
+				'DELETE_FAILED',
+				response.data,
+			);
+		}
+	}
+
+	/**
+	 * Fetch public events from any publisher (no identity needed).
+	 */
+	static async fetchPublicEvents(
+		options: PublicQueryOptions,
+	): Promise<PaginatedResult<PublicEventResult>> {
+		const params = new URLSearchParams();
+
+		if (options.channelId) {
+			params.set('channel_id', options.channelId);
+		}
+
+		if (options.tags?.length) {
+			params.set('tags', options.tags.join(','));
+		}
+
+		if (options.afterTimestamp) {
+			params.set('after', String(options.afterTimestamp));
+		}
+
+		if (options.beforeTimestamp) {
+			params.set('before', String(options.beforeTimestamp));
+		}
+
+		if (options.pagination) {
+			params.set('page', String(options.pagination.page));
+			params.set('page_size', String(options.pagination.pageSize));
+		}
+
+		const url = `${options.mediatorEndpoint}/public/${options.publisherDid}?${params.toString()}`;
+
+		interface PublicEventsResponse {
+			events: Array<{
+				id: string;
+				channel_id: string;
+				event: string;
+				tags: string[];
+				timestamp: number;
+				event_signature: string;
+			}>;
+			pagination: { page: number; page_size: number; total: number };
+		}
+
+		const response = await axiosModule.get<PublicEventsResponse>(url, {
+			timeout: DEFAULT_TIMEOUT_MS,
+		});
+
+		return {
+			data: response.data.events.map((e) => ({
+				id: e.id,
+				channelId: e.channel_id,
+				event: e.event,
+				tags: e.tags,
+				timestamp: e.timestamp,
+				eventSignature: e.event_signature,
+			})),
+			pagination: {
+				page: response.data.pagination.page,
+				pageSize: response.data.pagination.page_size,
+				total: response.data.pagination.total,
+			},
+		};
+	}
+
 	/**
 	 * Shared logic: filter by known senders, decrypt, store locally, acknowledge.
 	 */
@@ -370,7 +516,9 @@ export class DecentrlEventStore {
 
 				const event = JSON.parse(envelope.event) as T;
 
-				if (!(event as any)?.meta?.ephemeral) {
+				const eventWithMeta = event as { meta?: { ephemeral?: boolean } };
+
+				if (!eventWithMeta?.meta?.ephemeral) {
 					await this.storeReceivedEvent(event, pendingEvent.sender_did, contract.id);
 				}
 

package/src/types.ts

@@ -49,6 +49,34 @@ export interface PaginatedResult<T> {
 	pagination: PaginationMeta;
 }
 
+// --- Public Events ---
+
+export interface PublicPublishOptions {
+	channelId: string;
+	tags: string[];
+}
+
+export interface PublicQueryOptions {
+	mediatorEndpoint: string;
+	publisherDid: string;
+	channelId?: string;
+	tags?: string[];
+	/** Unix timestamp in seconds */
+	afterTimestamp?: number;
+	/** Unix timestamp in seconds */
+	beforeTimestamp?: number;
+	pagination?: { page: number; pageSize: number };
+}
+
+export interface PublicEventResult {
+	id: string;
+	channelId: string;
+	event: string;
+	tags: string[];
+	timestamp: number;
+	eventSignature: string;
+}
+
 export class EventStoreError extends Error {
 	constructor(
 		message: string,