@decentrl/event-store 0.0.1

package/src/event-store.test.ts

@@ -0,0 +1,341 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@decentrl/crypto', () => ({
+	base64Decode: vi.fn((s: string) => new TextEncoder().encode(s)),
+	base64Encode: vi.fn((u: Uint8Array) => new TextDecoder().decode(u)),
+	decryptString: vi.fn(),
+	encryptString: vi.fn((plaintext: string) => `encrypted:${plaintext}`),
+	generateEncryptedTag: vi.fn((_key: unknown, tag: string) => `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';
+import type { StoredSignedContract } from './types.js';
+
+const makeContract = (opts: {
+	id: string;
+	participantDid: string;
+	expiresAt: number;
+	timestamp: number;
+	rootSecret?: string;
+}): StoredSignedContract => ({
+	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: string[] = [];
+			const mockDecrypt = vi.mocked(decryptString);
+			mockDecrypt.mockImplementation((_payload, key) => {
+				const keyStr = new TextDecoder().decode(key as Uint8Array);
+				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();
+		});
+	});
+});