@decentrl/event-store 0.0.1

package/dist/event-store.test.js

@@ -0,0 +1,273 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@decentrl/crypto', () => ({
+    base64Decode: vi.fn((s) => new TextEncoder().encode(s)),
+    base64Encode: vi.fn((u) => new TextDecoder().decode(u)),
+    decryptString: vi.fn(),
+    encryptString: vi.fn((plaintext) => `encrypted:${plaintext}`),
+    generateEncryptedTag: vi.fn((_key, tag) => `etag:${tag}`),
+    signJsonObject: vi.fn(() => 'mock-signature'),
+    verifyJsonSignature: vi.fn(() => true),
+    multibaseDecode: vi.fn(() => new Uint8Array(32)),
+}));
+vi.mock('@decentrl/identity/communication-channels/mediator/direct-authenticated/command/command.service', () => ({
+    generateDirectAuthenticatedMediatorCommand: vi.fn(() => ({ mock: 'command' })),
+    generateTwoWayPrivateMediatorCommand: vi.fn(() => ({ mock: 'two-way-command' })),
+}));
+vi.mock('axios', () => ({
+    default: {
+        post: vi.fn(async () => ({ data: { type: 'SUCCESS', payload: {} } })),
+    },
+}));
+import { decryptString } from '@decentrl/crypto';
+import { DecentrlEventStore } from './event-store.js';
+const makeContract = (opts) => ({
+    id: opts.id,
+    participantDid: opts.participantDid,
+    signedCommunicationContract: {
+        communication_contract: {
+            requestor_did: 'did:decentrl:alice',
+            recipient_did: opts.participantDid,
+            requestor_signing_key_id: 'did:decentrl:alice#signing',
+            recipient_signing_key_id: `${opts.participantDid}#signing`,
+            requestor_encryption_public_key: 'key-a',
+            recipient_encryption_public_key: 'key-b',
+            expires_at: opts.expiresAt,
+            timestamp: opts.timestamp,
+        },
+        requestor_signature: 'sig-a',
+        recipient_signature: 'sig-b',
+    },
+    rootSecret: opts.rootSecret ?? 'secret-key',
+});
+const mockIdentity = {
+    did: 'did:decentrl:alice',
+    keys: {
+        signing: {
+            privateKey: new Uint8Array(32),
+            publicKey: new Uint8Array(32),
+        },
+        encryption: {
+            privateKey: new Uint8Array(32),
+            publicKey: new Uint8Array(32),
+        },
+        storageKey: new Uint8Array(32),
+    },
+    mediatorEndpoint: 'http://mediator',
+    mediatorDid: 'did:web:mediator',
+};
+describe('DecentrlEventStore', () => {
+    describe('processPreFetchedPendingEvents', () => {
+        it('tries multiple contracts for decryption', async () => {
+            const now = Math.floor(Date.now() / 1000);
+            const oldContract = makeContract({
+                id: 'old-contract',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 3600,
+                timestamp: now,
+                rootSecret: 'old-secret',
+            });
+            const newContract = makeContract({
+                id: 'new-contract',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 7200,
+                timestamp: now + 100,
+                rootSecret: 'new-secret',
+            });
+            const mockDecrypt = vi.mocked(decryptString);
+            mockDecrypt
+                .mockImplementationOnce(() => {
+                // First attempt with new-contract key fails
+                throw new Error('decryption failed');
+            })
+                .mockImplementationOnce(() => {
+                // Second attempt with old-contract key succeeds
+                return JSON.stringify({
+                    contract_id: 'old-contract',
+                    event: JSON.stringify({ type: 'test', data: 'hello' }),
+                    timestamp: now,
+                    signature: 'mock-signature',
+                });
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [oldContract, newContract],
+            });
+            const rawEvents = [
+                {
+                    id: 'event-1',
+                    sender_did: 'did:decentrl:bob',
+                    payload: 'encrypted-payload',
+                },
+            ];
+            const result = await eventStore.processPreFetchedPendingEvents(rawEvents);
+            expect(result).toHaveLength(1);
+            expect(mockDecrypt).toHaveBeenCalledTimes(2);
+        });
+        it('skips events from unknown senders', async () => {
+            const now = Math.floor(Date.now() / 1000);
+            const contract = makeContract({
+                id: 'c1',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 3600,
+                timestamp: now,
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [contract],
+            });
+            const rawEvents = [
+                {
+                    id: 'event-1',
+                    sender_did: 'did:decentrl:unknown',
+                    payload: 'encrypted-payload',
+                },
+            ];
+            const result = await eventStore.processPreFetchedPendingEvents(rawEvents);
+            expect(result).toHaveLength(0);
+        });
+        it('calls onContractUsed when event is successfully decrypted', async () => {
+            const now = Math.floor(Date.now() / 1000);
+            const contract = makeContract({
+                id: 'test-contract',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 3600,
+                timestamp: now,
+            });
+            const mockDecrypt = vi.mocked(decryptString);
+            mockDecrypt.mockReturnValue(JSON.stringify({
+                contract_id: 'test-contract',
+                event: JSON.stringify({ type: 'test', data: 'hello' }),
+                timestamp: now,
+                signature: 'mock-signature',
+            }));
+            const onContractUsed = vi.fn();
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [contract],
+                onContractUsed,
+            });
+            const rawEvents = [
+                {
+                    id: 'event-1',
+                    sender_did: 'did:decentrl:bob',
+                    payload: 'encrypted-payload',
+                },
+            ];
+            await eventStore.processPreFetchedPendingEvents(rawEvents);
+            expect(onContractUsed).toHaveBeenCalledWith('test-contract', 'did:decentrl:bob');
+        });
+        it('returns empty array when no active contracts exist', async () => {
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [],
+            });
+            const rawEvents = [
+                {
+                    id: 'event-1',
+                    sender_did: 'did:decentrl:bob',
+                    payload: 'encrypted-payload',
+                },
+            ];
+            const result = await eventStore.processPreFetchedPendingEvents(rawEvents);
+            expect(result).toHaveLength(0);
+        });
+        it('skips events that no contract can decrypt', async () => {
+            const now = Math.floor(Date.now() / 1000);
+            const contract = makeContract({
+                id: 'c1',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 3600,
+                timestamp: now,
+            });
+            const mockDecrypt = vi.mocked(decryptString);
+            mockDecrypt.mockImplementation(() => {
+                throw new Error('decryption failed');
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [contract],
+            });
+            const rawEvents = [
+                {
+                    id: 'event-1',
+                    sender_did: 'did:decentrl:bob',
+                    payload: 'encrypted-payload',
+                },
+            ];
+            const result = await eventStore.processPreFetchedPendingEvents(rawEvents);
+            expect(result).toHaveLength(0);
+        });
+        it('prefers contract with latest expires_at for decryption', async () => {
+            const now = Math.floor(Date.now() / 1000);
+            const oldContract = makeContract({
+                id: 'old',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 3600,
+                timestamp: now,
+                rootSecret: 'old-key',
+            });
+            const newContract = makeContract({
+                id: 'new',
+                participantDid: 'did:decentrl:bob',
+                expiresAt: now + 7200,
+                timestamp: now + 100,
+                rootSecret: 'new-key',
+            });
+            const decryptCalls = [];
+            const mockDecrypt = vi.mocked(decryptString);
+            mockDecrypt.mockImplementation((_payload, key) => {
+                const keyStr = new TextDecoder().decode(key);
+                decryptCalls.push(keyStr);
+                if (keyStr === 'new-key') {
+                    return JSON.stringify({
+                        contract_id: 'new',
+                        event: JSON.stringify({ type: 'test' }),
+                        timestamp: now,
+                        signature: 'mock-signature',
+                    });
+                }
+                throw new Error('wrong key');
+            });
+            const eventStore = new DecentrlEventStore({
+                identity: mockIdentity,
+                communicationContracts: () => [oldContract, newContract],
+            });
+            const rawEvents = [
+                {
+                    id: 'event-1',
+                    sender_did: 'did:decentrl:bob',
+                    payload: 'encrypted-payload',
+                },
+            ];
+            await eventStore.processPreFetchedPendingEvents(rawEvents);
+            // Should try new-key first (latest expires_at)
+            expect(decryptCalls[0]).toBe('new-key');
+        });
+    });
+    describe('publishEvent', () => {
+        beforeEach(() => {
+            vi.mocked(decryptString).mockReset();
+        });
+        it('stores locally for non-ephemeral events', async () => {
+            const axios = 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();
+        });
+        it('skips local storage for ephemeral events without recipient', async () => {
+            const axios = await import('axios');
+            vi.mocked(axios.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();
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { DecentrlEventStore } from './event-store';
+export type { EventStoreConfig, PaginatedResult, PaginationMeta, PublishOptions, QueryOptions, StoredSignedContract, } from './types';
+export { EventStoreError } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EACX,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,cAAc,EACd,YAAY,EACZ,oBAAoB,GACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { DecentrlEventStore } from './event-store';
+export { EventStoreError } from './types';

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+import type { DecentrlIdentityKeys } from '@decentrl/crypto';
+import type { SignedCommunicationContract } from '@decentrl/identity/communication-contract/communication-contract.schema';
+export interface EventStoreConfig {
+    identity: {
+        did: string;
+        keys: DecentrlIdentityKeys;
+        mediatorEndpoint: string;
+        mediatorDid: string;
+    };
+    communicationContracts: () => StoredSignedContract[];
+    onContractUsed?: (contractId: string, participantDid: string) => void;
+}
+/**
+ * Minimal contract shape needed by the event store.
+ * The canonical definition lives in @decentrl/sdk types.
+ */
+export interface StoredSignedContract {
+    id: string;
+    participantDid: string;
+    signedCommunicationContract: SignedCommunicationContract;
+    rootSecret: string;
+}
+export interface PublishOptions {
+    recipient?: string;
+    tags: string[];
+    ephemeral?: boolean;
+}
+export interface QueryOptions {
+    tags?: string[];
+    participantDid?: string;
+    afterTimestamp?: number;
+    beforeTimestamp?: number;
+    pagination?: {
+        page: number;
+        pageSize: number;
+    };
+    unprocessedOnly?: boolean;
+}
+export interface PaginationMeta {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+export interface PaginatedResult<T> {
+    data: T[];
+    pagination: PaginationMeta;
+}
+export declare class EventStoreError extends Error {
+    code: string;
+    details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,10 @@
+export class EventStoreError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'EventStoreError';
+    }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@decentrl/event-store",
+  "version": "0.0.1",
+  "description": "Event-driven storage and communication library for decentrl",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "@decentrl/crypto": "0.0.1",
+    "@decentrl/identity": "0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "vitest": "3.2.4"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:unit": "vitest run",
+    "dev": "tsc --watch"
+  }
+}