@decentrl/sdk 0.0.1

package/src/direct-transport.ts

@@ -0,0 +1,729 @@
+import {
+	base64Decode,
+	base64Encode,
+	decryptString,
+	deriveSharedSecret,
+	encryptString,
+	generateEncryptedTag,
+	generateIdentityKeys,
+} from '@decentrl/crypto';
+import { DecentrlEventStore } from '@decentrl/event-store';
+import { generateDirectAuthenticatedMediatorCommand } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/command.service';
+import type { QueryCommunicationContractsMediatorCommandResponse } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/query-communication-contracts.schema';
+import type { QueryPendingCommunicationContractRequestsMediatorCommandResponse } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/query-pending-communication-contracts.schema';
+import type { RequestCommunicationContractMediatorCommandResponse } from '@decentrl/identity/communication-channels/mediator/direct-authenticated/command/request-communication-contract.schema';
+import {
+	createCommunicationContractRequest,
+	decryptContractRequest,
+	generateContractId,
+	signCommunicationContract,
+} from '@decentrl/identity/communication-contract/communication-contract.service';
+import { createDecentrlDidFromKeys } from '@decentrl/identity/did-decentrl/did-decentrl.service';
+import { resolveDid } from '@decentrl/identity/did-resolver/resolver';
+import { resolveMediatorServiceEndpoint } from '@decentrl/identity/mediator/mediator.resolver';
+import axios from 'axios';
+import { DecentrlSDKError } from './errors.js';
+import { deserializeKeys, serializeIdentity } from './identity-serialization.js';
+import type { DecentrlTransport } from './transport.js';
+import type {
+	ArchivedContract,
+	EventEnvelope,
+	IdentityState,
+	PaginatedResult,
+	PendingContractRequest,
+	QueryOptions,
+	SerializedIdentity,
+	StoredSignedContract,
+} from './types.js';
+
+export type HttpPost = <T = unknown>(
+	url: string,
+	data: unknown,
+	options?: { timeout?: number },
+) => Promise<{ data: T }>;
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MEDIATOR_CONTRACT_LIFETIME_SECONDS = 3600 * 24 * 365; // 1 year
+const DEFAULT_CONTRACT_LIFETIME_SECONDS = 3600 * 24; // 24 hours
+
+export interface DirectTransportOptions {
+	httpPost?: HttpPost;
+	onEphemeralKeysChanged?: (keys: Record<string, string>) => void | Promise<void>;
+}
+
+export class DirectTransport implements DecentrlTransport {
+	private identity: IdentityState | null = null;
+	private eventStore: DecentrlEventStore | null = null;
+	private activeContracts: StoredSignedContract[] = [];
+	private httpPost: HttpPost;
+	private onEphemeralKeysChanged?: (keys: Record<string, string>) => void | Promise<void>;
+
+	private pendingEphemeralKeys = new Map<string, string>();
+	private knownRootSecrets = new Map<string, string>(); // contractId → rootSecret (survives refreshContracts)
+	private renewalInFlight = new Set<string>();
+	private supersededContracts = new Map<string, number>(); // contractId → supersededAt
+	private confirmedNewContracts = new Set<string>(); // contractIds confirmed by counterparty events
+	// Staging set: filled by processContractCleanup(), drained by refreshContracts().
+	// Must call refreshContracts() after cleanup to apply purges.
+	private purgedContractIds = new Set<string>();
+
+	constructor(options?: DirectTransportOptions) {
+		this.httpPost =
+			options?.httpPost ??
+			(<T>(url: string, data: unknown, opts?: { timeout?: number }) =>
+				axios.post<T>(url, data, { timeout: opts?.timeout ?? DEFAULT_TIMEOUT_MS }));
+		this.onEphemeralKeysChanged = options?.onEphemeralKeysChanged;
+	}
+
+	// --- Identity ---
+
+	async createIdentity(options: {
+		alias: string;
+		mediatorDid: string;
+	}): Promise<SerializedIdentity> {
+		const { alias, mediatorDid } = options;
+
+		const keys = generateIdentityKeys();
+		const did = createDecentrlDidFromKeys(alias, keys, mediatorDid);
+		const mediatorEndpoint = await resolveMediatorServiceEndpoint(mediatorDid);
+
+		const { encryptedPayload, ephemeralKeyPair } = await createCommunicationContractRequest(
+			did,
+			mediatorDid,
+			keys,
+			MEDIATOR_CONTRACT_LIFETIME_SECONDS,
+		);
+
+		const registrationCommand = generateDirectAuthenticatedMediatorCommand(
+			did,
+			`${did}#signing`,
+			mediatorDid,
+			{
+				type: 'REQUEST_COMMUNICATION_CONTRACT',
+				encrypted_contract_request: encryptedPayload,
+				requestor_ephemeral_public_key: base64Encode(ephemeralKeyPair.publicKey),
+			},
+			keys,
+		);
+
+		const response = await this.httpPost<RequestCommunicationContractMediatorCommandResponse>(
+			mediatorEndpoint,
+			registrationCommand,
+		);
+
+		if (
+			response.data.type !== 'SUCCESS' ||
+			response.data.code !== 'MEDIATOR_REGISTRATION_SUCCESS'
+		) {
+			throw new Error('Failed to register with mediator');
+		}
+
+		this.identity = {
+			did,
+			alias,
+			mediatorDid,
+			mediatorEndpoint,
+			keys,
+			mediatorContract: response.data.payload.signed_communication_contract,
+		};
+
+		this.eventStore = null;
+
+		return serializeIdentity(this.identity);
+	}
+
+	getIdentity(): SerializedIdentity | null {
+		return this.identity ? serializeIdentity(this.identity) : null;
+	}
+
+	loadIdentity(serialized: SerializedIdentity): void {
+		this.identity = {
+			did: serialized.did,
+			alias: serialized.alias,
+			mediatorDid: serialized.mediatorDid,
+			mediatorEndpoint: serialized.mediatorEndpoint,
+			keys: deserializeKeys(serialized),
+			mediatorContract: serialized.mediatorContract,
+		};
+		this.eventStore = null;
+	}
+
+	loadContracts(contracts: StoredSignedContract[]): void {
+		this.activeContracts = [...contracts];
+
+		for (const c of contracts) {
+			if (c.rootSecret) {
+				this.knownRootSecrets.set(c.id, c.rootSecret);
+			}
+		}
+
+		this.eventStore = null;
+	}
+
+	loadEphemeralKeys(keys: Record<string, string>): void {
+		this.pendingEphemeralKeys = new Map(Object.entries(keys));
+	}
+
+	getEphemeralKeys(): Record<string, string> {
+		return Object.fromEntries(this.pendingEphemeralKeys);
+	}
+
+	// --- Events ---
+
+	async publishEvent(
+		envelope: EventEnvelope,
+		options: { tags: string[]; recipient?: string; ephemeral?: boolean },
+	): Promise<void> {
+		const eventStore = this.requireEventStore();
+		await eventStore.publishEvent(envelope, {
+			tags: options.tags,
+			recipient: options.recipient,
+			ephemeral: options.ephemeral,
+		});
+	}
+
+	async processPendingEvents(): Promise<EventEnvelope[]> {
+		const eventStore = this.requireEventStore();
+
+		return eventStore.processPendingEvents<EventEnvelope>();
+	}
+
+	async processPreFetchedPendingEvents(
+		rawEvents: Array<{ id: string; sender_did: string; payload: string }>,
+	): Promise<EventEnvelope[]> {
+		const eventStore = this.requireEventStore();
+
+		return eventStore.processPreFetchedPendingEvents<EventEnvelope>(rawEvents);
+	}
+
+	async queryEvents(options?: QueryOptions): Promise<PaginatedResult<EventEnvelope>> {
+		const eventStore = this.requireEventStore();
+
+		return eventStore.queryEvents<EventEnvelope>(options);
+	}
+
+	async updateEventTags(events: Array<{ eventId: string; tags: string[] }>): Promise<void> {
+		const identity = this.requireIdentity();
+		const encrypted = events.map((e) => ({
+			eventId: e.eventId,
+			encryptedTags: e.tags.map((tag) =>
+				generateEncryptedTag(identity.keys.signing.privateKey, tag),
+			),
+		}));
+		const eventStore = this.requireEventStore();
+		await eventStore.updateEventTags(encrypted);
+	}
+
+	async queryUnprocessedEvents(pagination?: {
+		page: number;
+		pageSize: number;
+	}): Promise<PaginatedResult<EventEnvelope>> {
+		const eventStore = this.requireEventStore();
+
+		return eventStore.queryUnprocessedEvents<EventEnvelope>(pagination);
+	}
+
+	// --- Contracts ---
+
+	async requestContract(
+		recipientDid: string,
+		expiresIn = DEFAULT_CONTRACT_LIFETIME_SECONDS,
+	): Promise<void> {
+		const identity = this.requireIdentity();
+
+		const { request, ephemeralKeyPair, encryptedPayload } =
+			await createCommunicationContractRequest(
+				identity.did,
+				recipientDid,
+				identity.keys,
+				expiresIn,
+			);
+
+		const ephemeralKeyKey = `${identity.did}|${recipientDid}|${request.communication_contract.timestamp}`;
+		const encryptedEphemeralKey = encryptString(
+			base64Encode(ephemeralKeyPair.privateKey),
+			identity.keys.storageKey,
+		);
+		this.pendingEphemeralKeys.set(ephemeralKeyKey, encryptedEphemeralKey);
+		await this.notifyEphemeralKeysChanged();
+
+		const command = generateDirectAuthenticatedMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			recipientDid,
+			{
+				type: 'REQUEST_COMMUNICATION_CONTRACT',
+				encrypted_contract_request: encryptedPayload,
+				requestor_ephemeral_public_key: base64Encode(ephemeralKeyPair.publicKey),
+			},
+			identity.keys,
+		);
+
+		const response = await this.httpPost<RequestCommunicationContractMediatorCommandResponse>(
+			identity.mediatorEndpoint,
+			command,
+		);
+
+		if (response.data.type !== 'SUCCESS') {
+			throw new Error('Failed to request communication contract');
+		}
+	}
+
+	async getPendingContracts(): Promise<PendingContractRequest[]> {
+		const identity = this.requireIdentity();
+
+		const command = generateDirectAuthenticatedMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			identity.mediatorDid,
+			{
+				type: 'QUERY_PENDING_COMMUNICATION_CONTRACT_REQUESTS',
+				pagination: { page: 0, page_size: 50 },
+			},
+			identity.keys,
+		);
+
+		const response =
+			await this.httpPost<QueryPendingCommunicationContractRequestsMediatorCommandResponse>(
+				identity.mediatorEndpoint,
+				command,
+			);
+
+		if (response.data.type !== 'SUCCESS') {
+			throw new Error('Failed to query pending contract requests');
+		}
+
+		return response.data.payload.pending_communication_contract_requests.map((req) => ({
+			id: req.id,
+			senderDid: req.sender_did,
+			encryptedPayload: req.encrypted_contract_request,
+			requestorEphemeralPublicKey: req.requestor_ephemeral_public_key,
+		}));
+	}
+
+	async acceptContract(
+		pendingId: string,
+		encryptedPayload: string,
+		requestorEphemeralPublicKey: string,
+	): Promise<void> {
+		const identity = this.requireIdentity();
+
+		const contractRequest = decryptContractRequest(
+			encryptedPayload,
+			identity.keys.encryption.privateKey,
+			requestorEphemeralPublicKey,
+		);
+
+		const acknowledgeCommand = generateDirectAuthenticatedMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			identity.mediatorDid,
+			{
+				type: 'ACKNOWLEDGE_PENDING_COMMUNICATION_CONTRACT_REQUESTS',
+				communication_contract_ids: [pendingId],
+			},
+			identity.keys,
+		);
+
+		await this.httpPost(identity.mediatorEndpoint, acknowledgeCommand);
+
+		const { signedContract, rootSecret } = await signCommunicationContract(
+			contractRequest,
+			identity.keys,
+		);
+
+		const contractId = generateContractId(signedContract.communication_contract);
+
+		const saveCommand = generateDirectAuthenticatedMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			identity.mediatorDid,
+			{
+				type: 'SAVE_COMMUNICATION_CONTRACT',
+				signed_communication_contract: signedContract,
+			},
+			identity.keys,
+		);
+
+		await this.httpPost(identity.mediatorEndpoint, saveCommand);
+
+		const responseCommand = generateDirectAuthenticatedMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			contractRequest.communication_contract.requestor_did,
+			{
+				type: 'COMMUNICATION_CONTRACT_RESPONSE',
+				signed_communication_contract: signedContract,
+			},
+			identity.keys,
+		);
+
+		await this.httpPost(identity.mediatorEndpoint, responseCommand);
+
+		const participantDid = contractRequest.communication_contract.requestor_did;
+		const participantDoc = await resolveDid(participantDid);
+		const stored: StoredSignedContract = {
+			id: contractId,
+			participantDid,
+			participantAlias: participantDoc?.alias?.[0],
+			signedCommunicationContract: signedContract,
+			rootSecret: base64Encode(rootSecret),
+			createdAt: Date.now(),
+			status: 'active',
+		};
+
+		this.knownRootSecrets.set(contractId, stored.rootSecret);
+		this.activeContracts = [...this.activeContracts, stored];
+	}
+
+	async refreshContracts(): Promise<StoredSignedContract[]> {
+		const identity = this.requireIdentity();
+
+		const command = generateDirectAuthenticatedMediatorCommand(
+			identity.did,
+			`${identity.did}#signing`,
+			identity.mediatorDid,
+			{
+				type: 'QUERY_COMMUNICATION_CONTRACTS',
+				filter: {},
+				pagination: { page: 0, page_size: 100 },
+			},
+			identity.keys,
+		);
+
+		const response = await this.httpPost<QueryCommunicationContractsMediatorCommandResponse>(
+			identity.mediatorEndpoint,
+			command,
+		);
+
+		if (response.data.type !== 'SUCCESS') {
+			throw new Error('Failed to query communication contracts');
+		}
+
+		const contracts: StoredSignedContract[] = [];
+
+		for (const contract of response.data.payload.communication_contracts) {
+			const signed = contract.signed_communication_contract;
+			const participantDid =
+				signed.communication_contract.requestor_did === identity.did
+					? signed.communication_contract.recipient_did
+					: signed.communication_contract.requestor_did;
+
+			const isExpired = signed.communication_contract.expires_at * 1000 < Date.now();
+
+			const contractId = generateContractId(signed.communication_contract);
+
+			let rootSecret = '';
+			const existingContract = this.activeContracts.find((c) => c.id === contractId);
+
+			const knownSecret = this.knownRootSecrets.get(contractId);
+
+			if (knownSecret) {
+				rootSecret = knownSecret;
+			} else if (existingContract?.rootSecret) {
+				rootSecret = existingContract.rootSecret;
+			} else {
+				const ephemeralKeyKey = `${identity.did}|${participantDid}|${signed.communication_contract.timestamp}`;
+				const encryptedEphemeralKey = this.pendingEphemeralKeys.get(ephemeralKeyKey);
+
+				if (encryptedEphemeralKey) {
+					const ephemeralPrivateKeyB64 = decryptString(
+						encryptedEphemeralKey,
+						identity.keys.storageKey,
+					);
+					const ephemeralPrivateKey = base64Decode(ephemeralPrivateKeyB64);
+
+					// DH(requestor_ephemeral_private, recipient_ephemeral_public)
+					const recipientEphemeralPublicKey =
+						signed.communication_contract.recipient_encryption_public_key;
+
+					if (recipientEphemeralPublicKey) {
+						const secret = deriveSharedSecret(
+							ephemeralPrivateKey,
+							base64Decode(recipientEphemeralPublicKey),
+						);
+						rootSecret = base64Encode(secret);
+						this.knownRootSecrets.set(contractId, rootSecret);
+						this.pendingEphemeralKeys.delete(ephemeralKeyKey);
+						await this.notifyEphemeralKeysChanged();
+					}
+				}
+			}
+
+			let participantAlias = existingContract?.participantAlias;
+
+			if (!participantAlias) {
+				const participantDoc = await resolveDid(participantDid);
+				participantAlias = participantDoc?.alias?.[0];
+			}
+
+			contracts.push({
+				id: contractId,
+				participantDid,
+				participantAlias,
+				signedCommunicationContract: signed,
+				rootSecret,
+				createdAt: Date.now(),
+				status: isExpired ? 'expired' : 'active',
+			});
+		}
+
+		this.activeContracts = contracts.filter(
+			(c) => c.status === 'active' && !this.purgedContractIds.has(c.id),
+		);
+		this.purgedContractIds.clear();
+
+		return contracts;
+	}
+
+	getActiveContracts(): StoredSignedContract[] {
+		return this.activeContracts;
+	}
+
+	async processAutoRenewals(threshold = 0.2): Promise<void> {
+		await this.initiateRenewals(threshold);
+		await this.autoAcceptRenewals();
+	}
+
+	private async initiateRenewals(threshold: number): Promise<void> {
+		const identity = this.requireIdentity();
+		const now = Date.now();
+
+		for (const contract of this.activeContracts) {
+			const cc = contract.signedCommunicationContract.communication_contract;
+			const lifetimeMs = (cc.expires_at - cc.timestamp) * 1000;
+			const elapsedMs = now - cc.timestamp * 1000;
+
+			if (elapsedMs < lifetimeMs * (1 - threshold)) {
+				continue;
+			}
+
+			// Deterministic initiator: lower DID always sends the renewal request
+			if (identity.did >= contract.participantDid) {
+				continue;
+			}
+
+			if (this.renewalInFlight.has(contract.participantDid)) {
+				continue;
+			}
+
+			this.renewalInFlight.add(contract.participantDid);
+
+			try {
+				const lifetimeSeconds = cc.expires_at - cc.timestamp;
+				await this.requestContract(contract.participantDid, lifetimeSeconds);
+			} catch (err) {
+				console.error('[Decentrl] Auto-renewal request failed:', err);
+			} finally {
+				this.renewalInFlight.delete(contract.participantDid);
+			}
+		}
+	}
+
+	private async autoAcceptRenewals(): Promise<void> {
+		const identity = this.requireIdentity();
+
+		const activeDids = new Map<string, StoredSignedContract>();
+
+		for (const contract of this.activeContracts) {
+			const existing = activeDids.get(contract.participantDid);
+
+			if (
+				!existing ||
+				contract.signedCommunicationContract.communication_contract.expires_at >
+					existing.signedCommunicationContract.communication_contract.expires_at
+			) {
+				activeDids.set(contract.participantDid, contract);
+			}
+		}
+
+		let pending: PendingContractRequest[];
+
+		try {
+			pending = await this.getPendingContracts();
+		} catch (err) {
+			console.error('[Decentrl] Auto-renewal: failed to fetch pending contracts:', err);
+
+			return;
+		}
+
+		for (const req of pending) {
+			const existingContract = activeDids.get(req.senderDid);
+
+			if (!existingContract) {
+				continue;
+			}
+
+			try {
+				const decrypted = decryptContractRequest(
+					req.encryptedPayload,
+					identity.keys.encryption.privateKey,
+					req.requestorEphemeralPublicKey,
+				);
+
+				const existingCc = existingContract.signedCommunicationContract.communication_contract;
+				const existingLifetime = existingCc.expires_at - existingCc.timestamp;
+				const newCc = decrypted.communication_contract;
+				const newLifetime = newCc.expires_at - newCc.timestamp;
+
+				if (existingLifetime !== newLifetime) {
+					continue;
+				}
+
+				await this.acceptContract(req.id, req.encryptedPayload, req.requestorEphemeralPublicKey);
+			} catch (err) {
+				console.error('[Decentrl] Auto-renewal accept failed:', err);
+			}
+		}
+	}
+
+	async processContractCleanup(): Promise<void> {
+		const now = Date.now();
+		const CLEANUP_TIMEOUT_MS = 7 * 24 * 60 * 60 * 1000;
+
+		// Group active contracts by participantDid
+		const byParticipant = new Map<string, StoredSignedContract[]>();
+
+		for (const contract of this.activeContracts) {
+			const list = byParticipant.get(contract.participantDid) ?? [];
+			list.push(contract);
+			byParticipant.set(contract.participantDid, list);
+		}
+
+		const toArchive: Array<{ contract: StoredSignedContract; supersededBy: string }> = [];
+
+		for (const [, contracts] of byParticipant) {
+			if (contracts.length < 2) {
+				continue;
+			}
+
+			contracts.sort(
+				(a, b) =>
+					b.signedCommunicationContract.communication_contract.expires_at -
+					a.signedCommunicationContract.communication_contract.expires_at,
+			);
+
+			const newestId = contracts[0].id;
+
+			for (let i = 1; i < contracts.length; i++) {
+				const old = contracts[i];
+
+				if (!this.supersededContracts.has(old.id)) {
+					this.supersededContracts.set(old.id, now);
+				}
+
+				const supersededAt = this.supersededContracts.get(old.id)!;
+				const isTimedOut = now - supersededAt >= CLEANUP_TIMEOUT_MS;
+				const isCounterpartyConfirmed = this.confirmedNewContracts.has(newestId);
+
+				if (isTimedOut || isCounterpartyConfirmed) {
+					this.purgedContractIds.add(old.id);
+					this.supersededContracts.delete(old.id);
+					toArchive.push({ contract: old, supersededBy: newestId });
+				}
+			}
+		}
+
+		// Remove purged contracts immediately so getActiveContracts() reflects the change.
+		// refreshContracts() will also filter them (and clear the staging set).
+		if (this.purgedContractIds.size > 0) {
+			this.activeContracts = this.activeContracts.filter((c) => !this.purgedContractIds.has(c.id));
+		}
+
+		// Publish archived events (best-effort)
+		if (toArchive.length > 0 && this.identity) {
+			const identity = this.identity;
+
+			for (const { contract, supersededBy } of toArchive) {
+				try {
+					const cc = contract.signedCommunicationContract.communication_contract;
+					await this.requireEventStore().publishEvent(
+						{
+							type: 'decentrl.contract.archived',
+							data: {
+								contractId: contract.id,
+								participantDid: contract.participantDid,
+								participantAlias: contract.participantAlias,
+								timestamp: cc.timestamp,
+								expiresAt: cc.expires_at,
+								supersededAt: now,
+								supersededBy,
+							},
+							meta: {
+								senderDid: identity.did,
+								timestamp: now,
+								eventId: crypto.randomUUID(),
+							},
+						},
+						{ tags: ['decentrl.contract.archived'] },
+					);
+				} catch (err) {
+					console.error('[Decentrl] Failed to archive contract:', err);
+				}
+			}
+		}
+	}
+
+	async getContractHistory(): Promise<ArchivedContract[]> {
+		const eventStore = this.requireEventStore();
+		const result = await eventStore.queryEvents<EventEnvelope>({
+			tags: ['decentrl.contract.archived'],
+		});
+
+		return result.data
+			.filter((e): e is EventEnvelope & { data: ArchivedContract } => {
+				const d = e.data;
+
+				return (
+					d != null &&
+					typeof d === 'object' &&
+					'contractId' in d &&
+					'participantDid' in d &&
+					'supersededBy' in d
+				);
+			})
+			.map((e) => e.data);
+	}
+
+	dispose(): void {
+		this.eventStore = null;
+	}
+
+	// --- Internal helpers ---
+
+	private async notifyEphemeralKeysChanged(): Promise<void> {
+		await this.onEphemeralKeysChanged?.(Object.fromEntries(this.pendingEphemeralKeys));
+	}
+
+	private requireIdentity(): IdentityState {
+		if (!this.identity) {
+			throw new DecentrlSDKError(
+				'Identity not initialized. Call createIdentity() or loadIdentity() first.',
+				'IDENTITY_NOT_INITIALIZED',
+			);
+		}
+
+		return this.identity;
+	}
+
+	private requireEventStore(): DecentrlEventStore {
+		const identity = this.requireIdentity();
+
+		if (!this.eventStore) {
+			this.eventStore = new DecentrlEventStore({
+				identity: {
+					did: identity.did,
+					keys: identity.keys,
+					mediatorEndpoint: identity.mediatorEndpoint,
+					mediatorDid: identity.mediatorDid,
+				},
+				communicationContracts: () => this.activeContracts,
+				onContractUsed: (contractId) => {
+					this.confirmedNewContracts.add(contractId);
+				},
+			});
+		}
+
+		return this.eventStore;
+	}
+}