@twin.org/synchronised-storage-service 0.0.1-next.9 → 0.0.3-next.2

package/dist/esm/index.mjs

@@ -1,2227 +0,0 @@
-import { property, entity, EntitySchemaFactory, EntitySchemaHelper, ComparisonOperator } from '@twin.org/entity';
-import { Guards, ComponentFactory, Is, Converter, Compression, CompressionType, ObjectHelper, BaseError, GeneralError, RandomHelper, NotFoundError, UnauthorizedError } from '@twin.org/core';
-import { HttpStatusCode } from '@twin.org/web';
-import { BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
-import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-import { DocumentHelper, IdentityConnectorFactory } from '@twin.org/identity-models';
-import { ProofTypes } from '@twin.org/standards-w3c-did';
-import { SyncChangeOperation, SynchronisedStorageTopics, SyncNodeIdentityMode } from '@twin.org/synchronised-storage-models';
-import { VaultEncryptionType, VaultConnectorFactory } from '@twin.org/vault-models';
-import { VerifiableStorageConnectorFactory } from '@twin.org/verifiable-storage-models';
-import { RSA } from '@twin.org/crypto';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class representing an entry for the sync snapshot.
- */
-let SyncSnapshotEntry = class SyncSnapshotEntry {
-    /**
-     * The id for the snapshot.
-     */
-    id;
-    /**
-     * The version for the snapshot.
-     */
-    version;
-    /**
-     * The storage key for the snapshot i.e. which entity is being synchronized.
-     */
-    storageKey;
-    /**
-     * The date the snapshot was created.
-     */
-    dateCreated;
-    /**
-     * The date the snapshot was last modified.
-     */
-    dateModified;
-    /**
-     * The flag to determine if this is the snapshot is the local one containing changes for this node.
-     */
-    isLocal;
-    /**
-     * The flag to determine if this is a consolidated snapshot.
-     */
-    isConsolidated;
-    /**
-     * The epoch for the changeset.
-     */
-    epoch;
-    /**
-     * The ids of the storage for the change sets in the snapshot, if this is not a local snapshot.
-     */
-    changeSetStorageIds;
-    /**
-     * The changes that were made in this snapshot, if this is a local snapshot.
-     */
-    changes;
-};
-__decorate([
-    property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], SyncSnapshotEntry.prototype, "id", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], SyncSnapshotEntry.prototype, "version", void 0);
-__decorate([
-    property({ type: "string", isSecondary: true }),
-    __metadata("design:type", String)
-], SyncSnapshotEntry.prototype, "storageKey", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], SyncSnapshotEntry.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], SyncSnapshotEntry.prototype, "dateModified", void 0);
-__decorate([
-    property({ type: "boolean" }),
-    __metadata("design:type", Boolean)
-], SyncSnapshotEntry.prototype, "isLocal", void 0);
-__decorate([
-    property({ type: "boolean" }),
-    __metadata("design:type", Boolean)
-], SyncSnapshotEntry.prototype, "isConsolidated", void 0);
-__decorate([
-    property({ type: "number" }),
-    __metadata("design:type", Number)
-], SyncSnapshotEntry.prototype, "epoch", void 0);
-__decorate([
-    property({ type: "array", itemType: "string", optional: true }),
-    __metadata("design:type", Array)
-], SyncSnapshotEntry.prototype, "changeSetStorageIds", void 0);
-__decorate([
-    property({ type: "array", itemType: "object", optional: true }),
-    __metadata("design:type", Array)
-], SyncSnapshotEntry.prototype, "changes", void 0);
-SyncSnapshotEntry = __decorate([
-    entity()
-], SyncSnapshotEntry);
-
-/**
- * The source used when communicating about these routes.
- */
-const ROUTES_SOURCE = "synchronisedStorageRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsSynchronisedStorage = [
-    {
-        name: "Synchronised Storage",
-        description: "Endpoints which are modelled to access a synchronised storage contract."
-    }
-];
-/**
- * The REST routes for synchronised storage.
- * @param baseRouteName Prefix to prepend to the paths.
- * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
- * @returns The generated routes.
- */
-function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
-    const syncChangeSetRoute = {
-        operationId: "synchronisedStorageSyncChangeSetRequest",
-        summary: "Request that the node perform a sync request for a changeset.",
-        tag: tagsSynchronisedStorage[0].name,
-        method: "POST",
-        path: `${baseRouteName}/sync-changeset`,
-        handler: async (httpRequestContext, request) => synchronisedStorageSyncChangeSetRequest(httpRequestContext, componentName, request),
-        requestType: {
-            type: "ISyncChangeSetRequest",
-            examples: [
-                {
-                    id: "synchronisedStorageSyncChangeSetRequestExample",
-                    request: {
-                        body: {
-                            id: "0909090909090909090909090909090909090909090909090909090909090909",
-                            dateCreated: "2025-05-29T01:00:00.000Z",
-                            dateModified: "2025-05-29T01:00:00.000Z",
-                            nodeIdentity: "did:entity-storage:0xd2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2",
-                            changes: [
-                                {
-                                    entity: {
-                                        dateModified: "2025-01-01T00:00:00.000Z"
-                                    },
-                                    id: "test-id-1",
-                                    operation: "set"
-                                }
-                            ],
-                            proof: {
-                                "@context": "https://www.w3.org/ns/credentials/v2",
-                                created: "2025-05-29T01:00:00.000Z",
-                                cryptosuite: "eddsa-jcs-2022",
-                                proofPurpose: "assertionMethod",
-                                proofValue: "z5efBErQs3YBLZoH7jgKMQaRc9YjAxA5XSYKmW3FmTBDw9WionT2NS2x1SMvcRyBvw53cSSoaCT1xQH9tkWngGCX3",
-                                type: "DataIntegrityProof",
-                                verificationMethod: "did:entity-storage:0xd0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0#synchronised-storage-assertion"
-                            },
-                            storageKey: "test-type"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            }
-        ],
-        // Authentication is provided by the proof in the request body.
-        skipAuth: true
-    };
-    const getDecryptionKeyRoute = {
-        operationId: "synchronisedStorageGetDecryptionKeyRequest",
-        summary: "Request the decryption key.",
-        tag: tagsSynchronisedStorage[0].name,
-        method: "POST",
-        path: `${baseRouteName}/decryption-key`,
-        handler: async (httpRequestContext, request) => synchronisedStorageGetDecryptionKeyRequest(httpRequestContext, componentName, request),
-        requestType: {
-            type: "ISyncChangeSetRequest",
-            examples: [
-                {
-                    id: "synchronisedStorageSyncGetDecryptionKeyRequestExample",
-                    request: {
-                        body: {
-                            nodeIdentity: "did:entity-storage:0xd2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2",
-                            proof: {
-                                "@context": "https://www.w3.org/ns/credentials/v2",
-                                created: "2025-05-29T01:00:00.000Z",
-                                cryptosuite: "eddsa-jcs-2022",
-                                proofPurpose: "assertionMethod",
-                                proofValue: "z5efBErQs3YBLZoH7jgKMQaRc9YjAxA5XSYKmW3FmTBDw9WionT2NS2x1SMvcRyBvw53cSSoaCT1xQH9tkWngGCX3",
-                                type: "DataIntegrityProof",
-                                verificationMethod: "did:entity-storage:0xd0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0#synchronised-storage-assertion"
-                            }
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "ISyncDecryptionKeyResponse",
-                examples: [
-                    {
-                        id: "synchronisedStorageSyncGetDecryptionKeyResponseExample",
-                        response: {
-                            body: {
-                                decryptionKey: "z5efBErQs3YBLZoH7jgKMQaRc9YjAxA5XSYKmW3FmTBDw9WionT2NS2x1SMvcRyBvw53cSSoaCT1xQH9tkWngGCX3"
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IUnauthorizedResponse"
-            }
-        ],
-        // Authentication is provided by the proof in the request body.
-        skipAuth: true
-    };
-    return [syncChangeSetRoute, getDecryptionKeyRoute];
-}
-/**
- * Perform the sync change set operation.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function synchronisedStorageSyncChangeSetRequest(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    const component = ComponentFactory.get(componentName);
-    await component.syncChangeSet(request.body);
-    return {
-        statusCode: HttpStatusCode.noContent
-    };
-}
-/**
- * Request the decryption key.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function synchronisedStorageGetDecryptionKeyRequest(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    const component = ComponentFactory.get(componentName);
-    const key = await component.getDecryptionKey(request.body.nodeIdentity, request.body.proof);
-    return {
-        body: {
-            decryptionKey: key
-        }
-    };
-}
-
-const restEntryPoints = [
-    {
-        name: "synchronised-storage",
-        defaultBaseRoute: "synchronised-storage",
-        tags: tagsSynchronisedStorage,
-        generateRoutes: generateRestRoutesSynchronisedStorage
-    }
-];
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialize the schema for the synchronised service.
- */
-function initSchema() {
-    EntitySchemaFactory.register("SyncSnapshotEntry", () => EntitySchemaHelper.getSchema(SyncSnapshotEntry));
-}
-
-var mainnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
-var testnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
-var devnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
-var verifiableStorageKeys = {
-	mainnet: mainnet,
-	testnet: testnet,
-	devnet: devnet
-};
-
-/**
- * Class for performing blob storage operations.
- */
-class BlobStorageHelper {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "BlobStorageHelper";
-    /**
-     * The logging component to use for logging.
-     * @internal
-     */
-    _loggingComponent;
-    /**
-     * The vault connector.
-     * @internal
-     */
-    _vaultConnector;
-    /**
-     * The blob storage connector to use.
-     * @internal
-     */
-    _blobStorageConnector;
-    /**
-     * The id of the vault key to use for encrypting/decrypting blobs.
-     * @internal
-     */
-    _blobStorageEncryptionKeyId;
-    /**
-     * Is this a trusted node.
-     * @internal
-     */
-    _isTrustedNode;
-    /**
-     * Create a new instance of BlobStorageHelper.
-     * @param loggingComponent The logging connector to use for logging.
-     * @param vaultConnector The vault connector to use for for the encryption key.
-     * @param blobStorageConnector The blob storage component to use.
-     * @param blobStorageEncryptionKeyId The id of the vault key to use for encrypting/decrypting blobs.
-     * @param isTrustedNode Is this a trusted node.
-     */
-    constructor(loggingComponent, vaultConnector, blobStorageConnector, blobStorageEncryptionKeyId, isTrustedNode) {
-        this._loggingComponent = loggingComponent;
-        this._vaultConnector = vaultConnector;
-        this._blobStorageConnector = blobStorageConnector;
-        this._blobStorageEncryptionKeyId = blobStorageEncryptionKeyId;
-        this._isTrustedNode = isTrustedNode;
-    }
-    /**
-     * Load a blob from storage.
-     * @param blobId The id of the blob to apply.
-     * @returns The blob.
-     */
-    async loadBlob(blobId) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "loadBlob",
-            data: {
-                blobId
-            }
-        });
-        try {
-            const encryptedBlob = await this._blobStorageConnector.get(blobId);
-            if (Is.uint8Array(encryptedBlob)) {
-                let compressedBlob;
-                // If this is a trusted node, we can decrypt the blob using the vault
-                if (this._isTrustedNode) {
-                    compressedBlob = await this._vaultConnector.decrypt(this._blobStorageEncryptionKeyId, VaultEncryptionType.Rsa2048, encryptedBlob);
-                }
-                else {
-                    // Otherwise we need the public key stored as a secret in the vault
-                    const key = await this._vaultConnector.getSecret(this._blobStorageEncryptionKeyId);
-                    const rsa = new RSA(Converter.base64ToBytes(key));
-                    compressedBlob = rsa.decrypt(encryptedBlob);
-                }
-                const decompressedBlob = await Compression.decompress(compressedBlob, CompressionType.Gzip);
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "loadedBlob",
-                    data: {
-                        blobId
-                    }
-                });
-                return ObjectHelper.fromBytes(decompressedBlob);
-            }
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "loadBlobFailed",
-                data: {
-                    blobId
-                },
-                error: BaseError.fromError(error)
-            });
-        }
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "loadBlobEmpty",
-            data: {
-                blobId
-            }
-        });
-    }
-    /**
-     * Save a blob.
-     * @param blob The blob to save.
-     * @returns The id of the blob.
-     */
-    async saveBlob(blob) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "saveBlob"
-        });
-        if (!this._isTrustedNode) {
-            throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
-        }
-        const compressedBlob = await Compression.compress(ObjectHelper.toBytes(blob), CompressionType.Gzip);
-        const encryptedBlob = await this._vaultConnector.encrypt(this._blobStorageEncryptionKeyId, VaultEncryptionType.Rsa2048, compressedBlob);
-        try {
-            const blobId = await this._blobStorageConnector.set(encryptedBlob);
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "savedBlob",
-                data: {
-                    blobId
-                }
-            });
-            return blobId;
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "saveBlobFailed",
-                error: BaseError.fromError(error)
-            });
-            throw error;
-        }
-    }
-    /**
-     * Remove a blob from storage.
-     * @param blobId The id of the blob to remove.
-     * @returns Nothing.
-     */
-    async removeBlob(blobId) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "removeBlob",
-            data: {
-                blobId
-            }
-        });
-        try {
-            await this._blobStorageConnector.remove(blobId);
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "removedBlob",
-                data: {
-                    blobId
-                }
-            });
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "removeBlobFailed",
-                data: {
-                    blobId
-                },
-                error: BaseError.fromError(error)
-            });
-        }
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "removeBlobEmpty",
-            data: {
-                blobId
-            }
-        });
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing change set operations.
- */
-class ChangeSetHelper {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "ChangeSetHelper";
-    /**
-     * The logging component to use for logging.
-     * @internal
-     */
-    _loggingComponent;
-    /**
-     * The event bus component.
-     * @internal
-     */
-    _eventBusComponent;
-    /**
-     * The blob storage helper to use for remote sync states.
-     * @internal
-     */
-    _blobStorageHelper;
-    /**
-     * The identity connector to use for signing/verifying changesets.
-     * @internal
-     */
-    _identityConnector;
-    /**
-     * The id of the identity method to use when signing/verifying changesets.
-     * @internal
-     */
-    _decentralisedStorageMethodId;
-    /**
-     * The identity of the node that is performing the update.
-     * @internal
-     */
-    _nodeIdentity;
-    /**
-     * Create a new instance of ChangeSetHelper.
-     * @param loggingComponent The logging connector to use for logging.
-     * @param eventBusComponent The event bus component to use for events.
-     * @param identityConnector The identity connector to use for signing/verifying changesets.
-     * @param blobStorageHelper The blob storage component to use for remote sync states.
-     * @param decentralisedStorageMethodId The id of the identity method to use when signing/verifying changesets.
-     */
-    constructor(loggingComponent, eventBusComponent, identityConnector, blobStorageHelper, decentralisedStorageMethodId) {
-        this._loggingComponent = loggingComponent;
-        this._eventBusComponent = eventBusComponent;
-        this._decentralisedStorageMethodId = decentralisedStorageMethodId;
-        this._blobStorageHelper = blobStorageHelper;
-        this._identityConnector = identityConnector;
-    }
-    /**
-     * Set the node identity to use for signing changesets.
-     * @param nodeIdentity The identity of the node that is performing the update.
-     */
-    setNodeIdentity(nodeIdentity) {
-        this._nodeIdentity = nodeIdentity;
-    }
-    /**
-     * Get and verify a changeset.
-     * @param changeSetStorageId The id of the sync changeset to apply.
-     * @returns The changeset if it was verified.
-     */
-    async getAndVerifyChangeset(changeSetStorageId) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "getChangeSet",
-            data: {
-                changeSetStorageId
-            }
-        });
-        try {
-            const syncChangeSet = await this._blobStorageHelper.loadBlob(changeSetStorageId);
-            if (Is.object(syncChangeSet)) {
-                const verified = await this.verifyChangesetProof(syncChangeSet);
-                return verified ? syncChangeSet : undefined;
-            }
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "warn",
-                source: this.CLASS_NAME,
-                message: "getChangeSetError",
-                data: {
-                    changeSetStorageId
-                },
-                error: BaseError.fromError(error)
-            });
-        }
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "getChangeSetEmpty",
-            data: {
-                changeSetStorageId
-            }
-        });
-    }
-    /**
-     * Apply a sync changeset.
-     * @param changeSetStorageId The id of the sync changeset to apply.
-     * @returns The changeset if it existed.
-     */
-    async getAndApplyChangeset(changeSetStorageId) {
-        const syncChangeset = await this.getAndVerifyChangeset(changeSetStorageId);
-        // Only apply changesets from other nodes, we don't want to overwrite
-        // any changes we have made to local entity storage
-        if (!Is.empty(syncChangeset) && syncChangeset.nodeIdentity !== this._nodeIdentity) {
-            await this.applyChangeset(syncChangeset);
-        }
-        return syncChangeset;
-    }
-    /**
-     * Apply a sync changeset.
-     * @param syncChangeset The sync changeset to apply.
-     * @returns Nothing.
-     */
-    async applyChangeset(syncChangeset) {
-        if (Is.arrayValue(syncChangeset.changes)) {
-            for (const change of syncChangeset.changes) {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "changeSetApplyingChange",
-                    data: {
-                        operation: change.operation,
-                        id: change.id
-                    }
-                });
-                switch (change.operation) {
-                    case SyncChangeOperation.Set:
-                        if (!Is.empty(change.entity)) {
-                            // The id was stripped from the entity as it is part of the operation
-                            // we make sure we reinstate it in the publish
-                            // Also the node identity was stripped when stored in the changeset
-                            // as the changeset is signed with the node identity.
-                            // so we need to restore it here.
-                            await this._eventBusComponent.publish(SynchronisedStorageTopics.RemoteItemSet, {
-                                storageKey: syncChangeset.storageKey,
-                                entity: {
-                                    ...change.entity,
-                                    id: change.id,
-                                    nodeIdentity: syncChangeset.nodeIdentity
-                                }
-                            });
-                        }
-                        break;
-                    case SyncChangeOperation.Delete:
-                        if (!Is.empty(change.id)) {
-                            await this._eventBusComponent.publish(SynchronisedStorageTopics.RemoteItemRemove, {
-                                storageKey: syncChangeset.storageKey,
-                                id: change.id,
-                                nodeIdentity: syncChangeset.nodeIdentity
-                            });
-                        }
-                        break;
-                }
-            }
-        }
-    }
-    /**
-     * Store the changeset.
-     * @param syncChangeSet The sync change set to store.
-     * @returns The id of the change set.
-     */
-    async storeChangeSet(syncChangeSet) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "changeSetStoring",
-            data: {
-                id: syncChangeSet.id
-            }
-        });
-        return this._blobStorageHelper.saveBlob(syncChangeSet);
-    }
-    /**
-     * Verify the proof of a sync changeset.
-     * @param syncChangeset The sync changeset to verify.
-     * @returns True if the proof is valid, false otherwise.
-     */
-    async verifyChangesetProof(syncChangeset) {
-        if (Is.empty(syncChangeset.proof)) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "verifyChangeSetProofMissing",
-                data: {
-                    snapshotId: syncChangeset.id
-                }
-            });
-            return false;
-        }
-        // If the proof or verification method is missing, the proof is invalid
-        const verificationMethod = syncChangeset.proof?.verificationMethod;
-        if (!Is.stringValue(verificationMethod)) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "verifyChangeSetProofMissing",
-                data: {
-                    id: syncChangeset.id
-                }
-            });
-        }
-        // Parse the verification method and extract the node identity
-        // this should match the node identity of the changeset
-        // otherwise you could sign a changeset for another node
-        const changeSetNodeIdentity = DocumentHelper.parseId(verificationMethod ?? "");
-        if (changeSetNodeIdentity.id !== syncChangeset.nodeIdentity) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "verifyChangeSetProofNodeIdentityMismatch",
-                data: {
-                    id: syncChangeset.id
-                }
-            });
-        }
-        const changeSetWithoutProof = ObjectHelper.clone(syncChangeset);
-        delete changeSetWithoutProof.proof;
-        const isValid = await this._identityConnector.verifyProof(changeSetWithoutProof, syncChangeset.proof);
-        if (!isValid) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "verifyChangeSetProofInvalid",
-                data: {
-                    id: syncChangeset.id
-                }
-            });
-        }
-        else {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "verifyChangeSetProofValid",
-                data: {
-                    id: syncChangeset.id
-                }
-            });
-        }
-        return isValid;
-    }
-    /**
-     * Create the proof of a sync change set.
-     * @param syncChangeset The sync changeset to create the proof for.
-     * @returns The proof.
-     */
-    async createChangeSetProof(syncChangeset) {
-        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", this._nodeIdentity);
-        const changeSetWithoutProof = ObjectHelper.clone(syncChangeset);
-        delete changeSetWithoutProof.proof;
-        const proof = await this._identityConnector.createProof(this._nodeIdentity, DocumentHelper.joinId(this._nodeIdentity, this._decentralisedStorageMethodId), ProofTypes.DataIntegrityProof, changeSetWithoutProof);
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "createdChangeSetProof",
-            data: {
-                id: syncChangeset.id,
-                ...proof
-            }
-        });
-        return proof;
-    }
-    /**
-     * Copy a change set.
-     * @param syncChangeSet The sync changeset to copy.
-     * @returns The id of the updated change set.
-     */
-    async copyChangeset(syncChangeSet) {
-        if (Is.stringValue(this._nodeIdentity)) {
-            const verified = await this.verifyChangesetProof(syncChangeSet);
-            if (verified) {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "copyChangeSet",
-                    data: {
-                        changeSetStorageId: syncChangeSet.id
-                    }
-                });
-                // Allocate a new id to the changeset copy and re-create a proof using this nodes identity
-                const copy = ObjectHelper.clone(syncChangeSet);
-                copy.id = Converter.bytesToHex(RandomHelper.generate(32));
-                copy.proof = await this.createChangeSetProof(copy);
-                // Store the copy
-                return {
-                    syncChangeSet: copy,
-                    changeSetStorageId: await this.storeChangeSet(copy)
-                };
-            }
-        }
-    }
-    /**
-     * Reset the storage for a given storage key.
-     * @param storageKey The key of the storage to reset.
-     * @param resetMode The reset mode, this will use the nodeIdentity in the entities to determine which are local/remote.
-     * @returns Nothing.
-     */
-    async reset(storageKey, resetMode) {
-        // If we are applying a consolidation we need to reset the local db
-        // but keep any entries from the local node, as they might have been updated
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "storageReset",
-            data: {
-                storageKey
-            }
-        });
-        await this._eventBusComponent.publish(SynchronisedStorageTopics.Reset, {
-            storageKey,
-            resetMode
-        });
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-const SYNC_STATE_VERSION = "1";
-const SYNC_POINTER_STORE_VERSION = "1";
-const SYNC_SNAPSHOT_VERSION = "1";
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing entity storage operations in decentralised storage.
- */
-class LocalSyncStateHelper {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "LocalSyncStateHelper";
-    /**
-     * The logging component to use for logging.
-     * @internal
-     */
-    _loggingComponent;
-    /**
-     * The storage connector for the sync snapshot entries.
-     * @internal
-     */
-    _snapshotEntryEntityStorage;
-    /**
-     * The change set helper to use for applying changesets.
-     * @internal
-     */
-    _changeSetHelper;
-    /**
-     * Create a new instance of LocalSyncStateHelper.
-     * @param loggingComponent The logging connector to use for logging.
-     * @param snapshotEntryEntityStorage The storage connector for the sync snapshot entries.
-     * @param changeSetHelper The change set helper to use for applying changesets.
-     */
-    constructor(loggingComponent, snapshotEntryEntityStorage, changeSetHelper) {
-        this._loggingComponent = loggingComponent;
-        this._snapshotEntryEntityStorage = snapshotEntryEntityStorage;
-        this._changeSetHelper = changeSetHelper;
-    }
-    /**
-     * Add a new change to the local snapshot.
-     * @param storageKey The storage key of the snapshot to add the change for.
-     * @param operation The operation to perform.
-     * @param id The id of the entity to add the change for.
-     * @returns Nothing.
-     */
-    async addLocalChange(storageKey, operation, id) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "addLocalChange",
-            data: {
-                storageKey,
-                operation,
-                id
-            }
-        });
-        const localChangeSnapshots = await this.getSnapshots(storageKey, true);
-        if (localChangeSnapshots.length > 0) {
-            const localChangeSnapshot = localChangeSnapshots[0];
-            localChangeSnapshot.changes ??= [];
-            // If we already have a change for this id we are
-            // about to supersede it, we remove the previous change
-            // to avoid having multiple changes for the same id
-            const previousChangeIndex = localChangeSnapshot.changes.findIndex(change => change.id === id);
-            if (previousChangeIndex !== -1) {
-                localChangeSnapshot.changes.splice(previousChangeIndex, 1);
-            }
-            // If we already have changes from previous updates
-            // then make sure we update the dateModified, otherwise
-            // we assume this is the first change and setting modified is not necessary
-            if (localChangeSnapshot.changes.length > 0) {
-                localChangeSnapshot.dateModified = new Date(Date.now()).toISOString();
-            }
-            localChangeSnapshot.changes.push({ operation, id });
-            await this.setLocalChangeSnapshot(localChangeSnapshot);
-        }
-    }
-    /**
-     * Get the snapshot which contains just the changes for this node.
-     * @param storageKey The storage key of the snapshot to get.
-     * @param isLocal Whether to get the local snapshot or not.
-     * @returns The local snapshot entry.
-     */
-    async getSnapshots(storageKey, isLocal) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "getSnapshots",
-            data: {
-                storageKey
-            }
-        });
-        const queryResult = await this._snapshotEntryEntityStorage.query({
-            conditions: [
-                {
-                    property: "isLocal",
-                    value: isLocal,
-                    comparison: ComparisonOperator.Equals
-                },
-                {
-                    property: "storageKey",
-                    value: storageKey,
-                    comparison: ComparisonOperator.Equals
-                }
-            ]
-        });
-        if (queryResult.entities.length > 0) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "getSnapshotsExists",
-                data: {
-                    storageKey
-                }
-            });
-            return queryResult.entities;
-        }
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "getSnapshotsDoesNotExist",
-            data: {
-                storageKey
-            }
-        });
-        const now = new Date(Date.now()).toISOString();
-        return [
-            {
-                version: SYNC_SNAPSHOT_VERSION,
-                id: Converter.bytesToHex(RandomHelper.generate(32)),
-                storageKey,
-                dateCreated: now,
-                dateModified: now,
-                changeSetStorageIds: [],
-                isLocal,
-                isConsolidated: false,
-                epoch: 0
-            }
-        ];
-    }
-    /**
-     * Set the current local snapshot with changes for this node.
-     * @param localChangeSnapshot The local change snapshot to set.
-     * @returns Nothing.
-     */
-    async setLocalChangeSnapshot(localChangeSnapshot) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "setLocalChangeSnapshot",
-            data: {
-                storageKey: localChangeSnapshot.storageKey
-            }
-        });
-        await this._snapshotEntryEntityStorage.set(localChangeSnapshot);
-    }
-    /**
-     * Get the current local snapshot with the changes for this node.
-     * @param localChangeSnapshot The local change snapshot to remove.
-     * @returns Nothing.
-     */
-    async removeLocalChangeSnapshot(localChangeSnapshot) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "removeLocalChangeSnapshot",
-            data: {
-                snapshotId: localChangeSnapshot.id
-            }
-        });
-        await this._snapshotEntryEntityStorage.remove(localChangeSnapshot.id);
-    }
-    /**
-     * Apply a sync state to the local node.
-     * @param storageKey The storage key of the snapshot to sync with.
-     * @param syncState The sync state to sync with.
-     * @returns Nothing.
-     */
-    async applySyncState(storageKey, syncState) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "applySyncState",
-            data: {
-                snapshotCount: syncState.snapshots.length
-            }
-        });
-        // Get all the existing snapshots that we have processed previously
-        let existingSnapshots = await this.getSnapshots(storageKey, false);
-        // Sort from newest to oldest
-        existingSnapshots = existingSnapshots.sort((a, b) => new Date(b.dateCreated).getTime() - new Date(a.dateCreated).getTime());
-        // Sort from newest to oldest
-        const syncStateSnapshots = syncState.snapshots.sort((a, b) => new Date(b.dateCreated).getTime() - new Date(a.dateCreated).getTime());
-        // Get the newest epoch from the local storage
-        const newestExistingEpoch = existingSnapshots[0]?.epoch ?? 0;
-        // Get the oldest epoch from the remote storage
-        const oldestSyncStateEpoch = syncStateSnapshots[syncStateSnapshots.length - 1]?.epoch ?? 0;
-        // If there is a gap between the largest epoch we have locally
-        // and the smallest epoch we have remotely then we have missed
-        // data so we need to perform a full sync
-        const hasEpochGap = newestExistingEpoch + 1 < oldestSyncStateEpoch;
-        // If we have an epoch gap or no existing snapshots then we need to apply
-        // a full sync from a consolidation
-        if (!existingSnapshots.some(s => s.isConsolidated) || hasEpochGap) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "applySnapshotNoExisting",
-                data: {
-                    storageKey
-                }
-            });
-            const mostRecentConsolidation = syncStateSnapshots.findIndex(snapshot => snapshot.isConsolidated);
-            if (mostRecentConsolidation !== -1) {
-                // We found the most recent consolidated snapshot, we can use it
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "applySnapshotFoundConsolidated",
-                    data: {
-                        storageKey,
-                        snapshotId: syncStateSnapshots[mostRecentConsolidation].id
-                    }
-                });
-                // We need to reset the entity storage and remove all the remote items
-                // so that we use just the ones from the consolidation, since
-                // we don't have any existing there shouldn't be any remote entries
-                // but we reset nonetheless
-                await this._changeSetHelper.reset(storageKey, SyncNodeIdentityMode.Remote);
-                // We need to process the most recent consolidation and all changes
-                // that were made since then, from newest to oldest (so newer changes override older ones)
-                // Process snapshots from the consolidation point (most recent) back to the newest
-                for (let i = mostRecentConsolidation; i >= 0; i--) {
-                    await this.processNewSnapshots([
-                        {
-                            ...syncStateSnapshots[i],
-                            storageKey,
-                            isLocal: false
-                        }
-                    ]);
-                }
-            }
-            else {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "applySnapshotNoConsolidated",
-                    data: {
-                        storageKey
-                    }
-                });
-            }
-        }
-        else {
-            // We have existing consolidated remote snapshots, so we can assume that we have
-            // applied at least one consolidation snapshot, in this case we need to look at the changes since
-            // then and apply them if we haven't already
-            // We don't need to apply any additional consolidated snapshots, just the changesets
-            // Create a lookup map for the existing snapshots
-            const existingSnapshotsMap = {};
-            for (const snapshot of existingSnapshots) {
-                existingSnapshotsMap[snapshot.id] = snapshot;
-            }
-            const newSnapshots = [];
-            const modifiedSnapshots = [];
-            const referencedExistingSnapshots = Object.keys(existingSnapshotsMap);
-            let completedProcessing = false;
-            for (const snapshot of syncStateSnapshots) {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "applySnapshot",
-                    data: {
-                        snapshotId: snapshot.id,
-                        dateCreated: new Date(snapshot.dateCreated).toISOString()
-                    }
-                });
-                // See if we have the snapshot stored locally
-                const currentSnapshot = existingSnapshotsMap[snapshot.id];
-                // As we are referencing an existing snapshot, we need to remove it from the list
-                // to allow us to cleanup any unreferenced snapshots later
-                const idx = referencedExistingSnapshots.indexOf(snapshot.id);
-                if (idx !== -1) {
-                    referencedExistingSnapshots.splice(idx, 1);
-                }
-                // No need to apply consolidated snapshots
-                if (!snapshot.isConsolidated && !completedProcessing) {
-                    const updatedSnapshot = {
-                        ...snapshot,
-                        storageKey,
-                        isLocal: false
-                    };
-                    if (Is.empty(currentSnapshot)) {
-                        // We don't have the snapshot locally, so we need to process all of it
-                        newSnapshots.push(updatedSnapshot);
-                    }
-                    else if (currentSnapshot.dateModified !== snapshot.dateModified) {
-                        // If the local snapshot has a different dateModified, we need to update it
-                        modifiedSnapshots.push({
-                            currentSnapshot,
-                            updatedSnapshot
-                        });
-                    }
-                    else {
-                        // we sorted the snapshots from newest to oldest, so if we found a local snapshot
-                        // with the same dateModified as the remote snapshot, we can stop processing further
-                        completedProcessing = true;
-                    }
-                }
-            }
-            // We reverse the order of the snapshots to process them from oldest to newest
-            // because we want to apply the changes in the order they were created
-            await this.processModifiedSnapshots(modifiedSnapshots.reverse());
-            await this.processNewSnapshots(newSnapshots.reverse());
-            // Any ids remaining in this list are no longer referenced in the global state
-            // so we should remove them from the local storage as they will never be updated again
-            for (const referencedSnapshotId of referencedExistingSnapshots) {
-                await this._snapshotEntryEntityStorage.remove(referencedSnapshotId);
-            }
-        }
-    }
-    /**
-     * Process the modified snapshots and store them in the local storage.
-     * @param modifiedSnapshots The modified snapshots to process.
-     * @returns Nothing.
-     * @internal
-     */
-    async processModifiedSnapshots(modifiedSnapshots) {
-        for (const modifiedSnapshot of modifiedSnapshots) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "processModifiedSnapshot",
-                data: {
-                    snapshotId: modifiedSnapshot.updatedSnapshot.id,
-                    localModified: new Date(modifiedSnapshot.currentSnapshot.dateModified ??
-                        modifiedSnapshot.currentSnapshot.dateCreated).toISOString(),
-                    remoteModified: new Date(modifiedSnapshot.updatedSnapshot.dateModified ??
-                        modifiedSnapshot.updatedSnapshot.dateCreated).toISOString()
-                }
-            });
-            const remoteChangeSetStorageIds = modifiedSnapshot.updatedSnapshot.changeSetStorageIds;
-            const localChangeSetStorageIds = modifiedSnapshot.currentSnapshot.changeSetStorageIds ?? [];
-            if (Is.arrayValue(remoteChangeSetStorageIds)) {
-                for (const storageId of remoteChangeSetStorageIds) {
-                    // Check if the local snapshot does not have the storageId
-                    if (!localChangeSetStorageIds.includes(storageId)) {
-                        await this._changeSetHelper.getAndApplyChangeset(storageId);
-                    }
-                }
-            }
-            await this._snapshotEntryEntityStorage.set(modifiedSnapshot.updatedSnapshot);
-        }
-    }
-    /**
-     * Process the new snapshots and store them in the local storage.
-     * @param newSnapshots The new snapshots to process.
-     * @returns Nothing.
-     * @internal
-     */
-    async processNewSnapshots(newSnapshots) {
-        for (const newSnapshot of newSnapshots) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "processNewSnapshot",
-                data: {
-                    snapshotId: newSnapshot.id,
-                    dateCreated: newSnapshot.dateCreated
-                }
-            });
-            const newSnapshotChangeSetStorageIds = newSnapshot.changeSetStorageIds ?? [];
-            if (Is.arrayValue(newSnapshotChangeSetStorageIds)) {
-                for (const storageId of newSnapshotChangeSetStorageIds) {
-                    await this._changeSetHelper.getAndApplyChangeset(storageId);
-                }
-            }
-            await this._snapshotEntryEntityStorage.set(newSnapshot);
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing entity storage operations in decentralised storage.
- */
-class RemoteSyncStateHelper {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "RemoteSyncStateHelper";
-    /**
-     * The logging component to use for logging.
-     * @internal
-     */
-    _loggingComponent;
-    /**
-     * The event bus component.
-     * @internal
-     */
-    _eventBusComponent;
-    /**
-     * The blob storage helper.
-     * @internal
-     */
-    _blobStorageHelper;
-    /**
-     * The verifiable storage connector to use for storing sync pointers.
-     * @internal
-     */
-    _verifiableSyncPointerStorageConnector;
-    /**
-     * The change set helper to use for applying changesets.
-     * @internal
-     */
-    _changeSetHelper;
-    /**
-     * The storage ids of the batch responses for each storage key.
-     * @internal
-     */
-    _batchResponseStorageIds;
-    /**
-     * The full changes for each storage key.
-     * @internal
-     */
-    _populateFullChanges;
-    /**
-     * The synchronised storage key to use for verified storage operations.
-     * @internal
-     */
-    _synchronisedStorageKey;
-    /**
-     * The identity of the node that is performing the update.
-     * @internal
-     */
-    _nodeIdentity;
-    /**
-     * Whether the node is trusted or not.
-     * @internal
-     */
-    _isTrustedNode;
-    /**
-     * Maximum number of consolidations to keep in storage.
-     * @internal
-     */
-    _maxConsolidations;
-    /**
-     * Create a new instance of DecentralisedEntityStorageConnector.
-     * @param loggingComponent The logging component to use for logging.
-     * @param eventBusComponent The event bus component to use for events.
-     * @param verifiableSyncPointerStorageConnector The verifiable storage connector to use for storing sync pointers.
-     * @param blobStorageHelper The blob storage helper to use for remote sync states.
-     * @param changeSetHelper The change set helper to use for managing changesets.
-     * @param isTrustedNode Whether the node is trusted or not.
-     * @param maxConsolidations The maximum number of consolidations to keep in storage.
-     */
-    constructor(loggingComponent, eventBusComponent, verifiableSyncPointerStorageConnector, blobStorageHelper, changeSetHelper, isTrustedNode, maxConsolidations) {
-        this._loggingComponent = loggingComponent;
-        this._eventBusComponent = eventBusComponent;
-        this._verifiableSyncPointerStorageConnector = verifiableSyncPointerStorageConnector;
-        this._changeSetHelper = changeSetHelper;
-        this._blobStorageHelper = blobStorageHelper;
-        this._isTrustedNode = isTrustedNode;
-        this._maxConsolidations = maxConsolidations;
-        this._batchResponseStorageIds = {};
-        this._populateFullChanges = {};
-        this._eventBusComponent.subscribe(SynchronisedStorageTopics.BatchResponse, async (response) => {
-            await this.handleBatchResponse(response.data);
-        });
-        this._eventBusComponent.subscribe(SynchronisedStorageTopics.LocalItemResponse, async (response) => {
-            await this.handleLocalItemResponse(response.data);
-        });
-    }
-    /**
-     * Set the node identity to use for signing changesets.
-     * @param nodeIdentity The identity of the node that is performing the update.
-     */
-    setNodeIdentity(nodeIdentity) {
-        this._nodeIdentity = nodeIdentity;
-    }
-    /**
-     * Set the synchronised storage key.
-     * @param synchronisedStorageKey The synchronised storage key to use.
-     */
-    setSynchronisedStorageKey(synchronisedStorageKey) {
-        this._synchronisedStorageKey = synchronisedStorageKey;
-    }
-    /**
-     * Build a changeset.
-     * @param storageKey The storage key of the change set.
-     * @param changes The changes to apply.
-     * @param completeCallback The callback to call when the changeset is created and stored.
-     * @returns The storage id of the change set if created.
-     */
-    async buildChangeSet(storageKey, changes, completeCallback) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "buildingChangeSet",
-            data: {
-                storageKey,
-                changeCount: changes.length
-            }
-        });
-        this._populateFullChanges[storageKey] = {
-            changes,
-            entities: {},
-            requestIds: [],
-            completeCallback: async () => this.finaliseFullChanges(storageKey, completeCallback)
-        };
-        const setChanges = changes.filter(c => c.operation === SyncChangeOperation.Set);
-        if (setChanges.length === 0) {
-            // If we don't need to request any full details, we can just call the complete callback
-            await this.finaliseFullChanges(storageKey, completeCallback);
-        }
-        else {
-            // Otherwise we need to request the full details for each change
-            this._populateFullChanges[storageKey].requestIds = setChanges.map(change => change.id);
-            // Once all the requests are handled the callback will be called
-            for (const change of setChanges) {
-                // Create a request for each change to populate the full details
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "createChangeSetRequestingItem",
-                    data: {
-                        storageKey,
-                        id: change.id
-                    }
-                });
-                this._eventBusComponent.publish(SynchronisedStorageTopics.LocalItemRequest, {
-                    storageKey,
-                    id: change.id
-                });
-            }
-        }
-    }
-    /**
-     * Finalise the full details for the sync change set.
-     * @param storageKey The storage key of the change set.
-     * @param completeCallback The callback to call when the changeset is populated.
-     * @returns Nothing.
-     */
-    async finaliseFullChanges(storageKey, completeCallback) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "finalisingSyncChanges",
-            data: {
-                storageKey
-            }
-        });
-        if (Is.stringValue(this._nodeIdentity)) {
-            const changes = this._populateFullChanges[storageKey].changes;
-            for (const change of changes) {
-                change.entity = this._populateFullChanges[storageKey].entities[change.id] ?? change.entity;
-                if (change.operation === SyncChangeOperation.Set && Is.objectValue(change.entity)) {
-                    // Remove the id from the entity as this is stored in the operation
-                    // and will be reinstated when the changeset is reconstituted
-                    ObjectHelper.propertyDelete(change.entity, "id");
-                    // Remove the node identity as the changeset has this stored at the top level
-                    // and we do not want to store it in the change itself to reduce redundancy
-                    ObjectHelper.propertyDelete(change.entity, "nodeIdentity");
-                }
-            }
-            const now = new Date(Date.now()).toISOString();
-            const syncChangeSet = {
-                id: Converter.bytesToHex(RandomHelper.generate(32)),
-                dateCreated: now,
-                dateModified: now,
-                storageKey,
-                changes,
-                nodeIdentity: this._nodeIdentity
-            };
-            try {
-                // And sign it with the node identity
-                syncChangeSet.proof = await this._changeSetHelper.createChangeSetProof(syncChangeSet);
-                // If this is a trusted node, we also store the changeset
-                let changeSetStorageId;
-                if (this._isTrustedNode) {
-                    changeSetStorageId = await this._changeSetHelper.storeChangeSet(syncChangeSet);
-                }
-                await completeCallback(syncChangeSet, changeSetStorageId);
-            }
-            catch (err) {
-                await this._loggingComponent?.log({
-                    level: "error",
-                    source: this.CLASS_NAME,
-                    message: "finalisingSyncChangesFailed",
-                    data: {
-                        storageKey
-                    },
-                    error: BaseError.fromError(err)
-                });
-                await completeCallback();
-            }
-        }
-        else {
-            await completeCallback();
-        }
-    }
-    /**
-     * Add a new changeset into the sync state.
-     * @param storageKey The storage key of the change set to add.
-     * @param changeSetStorageId The id of the change set to add the the current state
-     * @returns Nothing.
-     */
-    async addChangeSetToSyncState(storageKey, changeSetStorageId) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "addChangeSetToSyncState",
-            data: {
-                storageKey,
-                changeSetStorageId
-            }
-        });
-        // First load the sync pointer store to get the current sync pointer for the storage key
-        const syncPointerStore = await this.getVerifiableSyncPointerStore();
-        let syncState;
-        if (!Is.empty(syncPointerStore.syncPointers[storageKey])) {
-            syncState = await this.getSyncState(syncPointerStore.syncPointers[storageKey]);
-        }
-        // No current sync state, so we create a new one
-        if (Is.empty(syncState)) {
-            syncState = { version: SYNC_STATE_VERSION, storageKey, snapshots: [] };
-        }
-        // Sort the snapshots so the newest snapshot is last in the array
-        const sortedSnapshots = syncState.snapshots.sort((a, b) => a.dateCreated.localeCompare(b.dateCreated));
-        // Get the current snapshot, if it does not exist we create a new one
-        let currentSnapshot = sortedSnapshots[sortedSnapshots.length - 1];
-        const currentEpoch = currentSnapshot?.epoch ?? 0;
-        const now = new Date(Date.now()).toISOString();
-        // If there is no snapshot or the current one is a consolidation
-        // we start a new snapshot
-        if (Is.empty(currentSnapshot) || currentSnapshot.isConsolidated) {
-            currentSnapshot = {
-                version: SYNC_SNAPSHOT_VERSION,
-                id: Converter.bytesToHex(RandomHelper.generate(32)),
-                dateCreated: now,
-                dateModified: now,
-                isConsolidated: false,
-                epoch: currentEpoch + 1,
-                changeSetStorageIds: []
-            };
-            syncState.snapshots.push(currentSnapshot);
-        }
-        else {
-            // Snapshot exists, we update the dateModified
-            currentSnapshot.dateModified = now;
-        }
-        // Add the changeset storage id to the current snapshot
-        currentSnapshot.changeSetStorageIds.push(changeSetStorageId);
-        // Store the sync state in the blob storage
-        syncPointerStore.syncPointers[storageKey] = await this.storeRemoteSyncState(syncState);
-        // Store the verifiable sync pointer store in the verifiable storage
-        await this.storeVerifiableSyncPointerStore(syncPointerStore);
-    }
-    /**
-     * Create a consolidated snapshot for the entire storage.
-     * @param storageKey The storage key of the snapshot to create.
-     * @param batchSize The batch size to use for consolidation.
-     * @returns Nothing.
-     */
-    async consolidationStart(storageKey, batchSize) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "consolidationStarting"
-        });
-        // Perform a batch request to start the consolidation
-        await this._eventBusComponent.publish(SynchronisedStorageTopics.BatchRequest, { storageKey, batchSize, requestMode: SyncNodeIdentityMode.All });
-    }
-    /**
-     * Get the sync pointer store.
-     * @returns The sync pointer store.
-     */
-    async getVerifiableSyncPointerStore() {
-        if (Is.stringValue(this._synchronisedStorageKey)) {
-            try {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "verifiableSyncPointerStoreRetrieving",
-                    data: {
-                        key: this._synchronisedStorageKey
-                    }
-                });
-                const syncPointerStore = await this._verifiableSyncPointerStorageConnector.get(this._synchronisedStorageKey, { includeData: true });
-                if (Is.uint8Array(syncPointerStore.data)) {
-                    const syncPointer = ObjectHelper.fromBytes(syncPointerStore.data);
-                    await this._loggingComponent?.log({
-                        level: "info",
-                        source: this.CLASS_NAME,
-                        message: "verifiableSyncPointerStoreRetrieved",
-                        data: {
-                            key: this._synchronisedStorageKey
-                        }
-                    });
-                    return syncPointer;
-                }
-            }
-            catch (err) {
-                if (!BaseError.someErrorName(err, NotFoundError.CLASS_NAME)) {
-                    throw err;
-                }
-            }
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "verifiableSyncPointerStoreNotFound",
-                data: {
-                    key: this._synchronisedStorageKey
-                }
-            });
-        }
-        // If no sync pointer store exists, we return an empty one
-        return {
-            version: SYNC_POINTER_STORE_VERSION,
-            syncPointers: {}
-        };
-    }
-    /**
-     * Store the verifiable sync pointer in the verifiable storage.
-     * @param syncPointerStore The sync pointer store to store.
-     * @returns Nothing.
-     */
-    async storeVerifiableSyncPointerStore(syncPointerStore) {
-        if (Is.stringValue(this._nodeIdentity) && Is.stringValue(this._synchronisedStorageKey)) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "verifiableSyncPointerStoreStoring",
-                data: {
-                    key: this._synchronisedStorageKey
-                }
-            });
-            // Store the verifiable sync pointer in the verifiable storage
-            await this._verifiableSyncPointerStorageConnector.update(this._nodeIdentity, this._synchronisedStorageKey, ObjectHelper.toBytes(syncPointerStore));
-        }
-    }
-    /**
-     * Store the remote sync state.
-     * @param syncState The sync state to store.
-     * @returns The id of the sync state.
-     */
-    async storeRemoteSyncState(syncState) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "syncStateStoring",
-            data: {
-                snapshotCount: syncState.snapshots.length
-            }
-        });
-        // Limits the number of consolidations in the list so that we can shrink decentralised
-        // storage requirements, sort from newest to oldest so that we can easily find the
-        // oldest snapshots to remove.
-        const snapshots = syncState.snapshots.sort((a, b) => new Date(a.dateCreated).getTime() - new Date(b.dateCreated).getTime());
-        // Find all the consolidation indexes
-        const consolidationIndexes = [];
-        for (let i = 0; i < snapshots.length; i++) {
-            const snapshot = snapshots[i];
-            if (snapshot.isConsolidated) {
-                consolidationIndexes.push(i);
-            }
-        }
-        if (consolidationIndexes.length > this._maxConsolidations) {
-            // Once we have reached the max for consolidations we need to remove
-            // all the snapshots, including non consolidated ones, beyond this point
-            const toRemove = snapshots.slice(consolidationIndexes[this._maxConsolidations - 1] + 1);
-            syncState.snapshots = snapshots.slice(0, consolidationIndexes[this._maxConsolidations - 1] + 1);
-            for (const snapshot of toRemove) {
-                // We need to remove all the storage ids associated with the snapshot
-                if (Is.arrayValue(snapshot.changeSetStorageIds)) {
-                    for (const storageId of snapshot.changeSetStorageIds) {
-                        await this._blobStorageHelper.removeBlob(storageId);
-                    }
-                }
-            }
-        }
-        return this._blobStorageHelper.saveBlob(syncState);
-    }
-    /**
-     * Get the remote sync state.
-     * @param syncPointerId The id of the sync pointer to retrieve the state for.
-     * @returns The remote sync state.
-     */
-    async getSyncState(syncPointerId) {
-        try {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "syncStateRetrieving",
-                data: {
-                    syncPointerId
-                }
-            });
-            const syncState = await this._blobStorageHelper.loadBlob(syncPointerId);
-            if (Is.object(syncState)) {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "syncStateRetrieved",
-                    data: {
-                        syncPointerId,
-                        snapshotCount: syncState.snapshots.length
-                    }
-                });
-                return syncState;
-            }
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "warn",
-                source: this.CLASS_NAME,
-                message: "getSyncStateError",
-                data: {
-                    syncPointerId
-                },
-                error: BaseError.fromError(error)
-            });
-        }
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "syncStateNotFound",
-            data: {
-                syncPointerId
-            }
-        });
-    }
-    /**
-     * Handle the batch response which is triggered from a consolidation request.
-     * @param response The batch response to handle.
-     */
-    async handleBatchResponse(response) {
-        if (Is.stringValue(this._nodeIdentity)) {
-            const now = new Date(Date.now()).toISOString();
-            // Create a new snapshot entry for the current batch
-            const syncChangeSet = {
-                id: Converter.bytesToHex(RandomHelper.generate(32)),
-                dateCreated: now,
-                dateModified: now,
-                changes: response.entities.map(change => ({
-                    operation: SyncChangeOperation.Set,
-                    id: change.id
-                })),
-                storageKey: response.storageKey,
-                nodeIdentity: this._nodeIdentity
-            };
-            // And sign it with the node identity
-            syncChangeSet.proof = await this._changeSetHelper.createChangeSetProof(syncChangeSet);
-            // Store the changeset in the blob storage
-            const changeSetStorageId = await this._changeSetHelper.storeChangeSet(syncChangeSet);
-            // Add the changeset storage id to the snapshot ids
-            this._batchResponseStorageIds[response.storageKey] ??= [];
-            this._batchResponseStorageIds[response.storageKey].push(changeSetStorageId);
-            // If this is the last entry in the batch response, we can create the consolidated snapshot
-            if (response.lastEntry) {
-                // Get the current sync pointer store
-                const syncPointerStore = await this.getVerifiableSyncPointerStore();
-                let syncState;
-                if (Is.stringValue(syncPointerStore.syncPointers[response.storageKey])) {
-                    // If the sync pointer exists, we load the current sync state
-                    syncState = await this.getSyncState(syncPointerStore.syncPointers[response.storageKey]);
-                }
-                // If the sync state does not exist, we create a new one
-                syncState ??= {
-                    version: SYNC_STATE_VERSION,
-                    storageKey: response.storageKey,
-                    snapshots: []
-                };
-                // Sort the snapshots so the newest snapshot is last in the array
-                const sortedSnapshots = syncState.snapshots.sort((a, b) => a.dateCreated.localeCompare(b.dateCreated));
-                const currentSnapshot = sortedSnapshots[sortedSnapshots.length - 1];
-                const currentEpoch = currentSnapshot?.epoch ?? 0;
-                const batchSnapshot = {
-                    version: SYNC_SNAPSHOT_VERSION,
-                    id: Converter.bytesToHex(RandomHelper.generate(32)),
-                    dateCreated: now,
-                    dateModified: now,
-                    isConsolidated: true,
-                    epoch: currentEpoch + 1,
-                    changeSetStorageIds: this._batchResponseStorageIds[response.storageKey]
-                };
-                syncState.snapshots.push(batchSnapshot);
-                // Store the updated sync state
-                const syncStateId = await this.storeRemoteSyncState(syncState);
-                syncPointerStore.syncPointers[response.storageKey] = syncStateId;
-                // Store the verifiable sync pointer in the verifiable storage
-                await this.storeVerifiableSyncPointerStore(syncPointerStore);
-                // Remove the batch response storage ids for the storage key
-                // as we have consolidated the changes
-                delete this._batchResponseStorageIds[response.storageKey];
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "consolidationCompleted"
-                });
-            }
-        }
-    }
-    /**
-     * Handle the item response.
-     * @param response The item response to handle.
-     */
-    async handleLocalItemResponse(response) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "createChangeSetRespondingItem",
-            data: {
-                storageKey: response.storageKey,
-                id: response.id
-            }
-        });
-        // We have received a response to an item request, find the right storage
-        // for the request id
-        if (!Is.empty(this._populateFullChanges[response.storageKey])) {
-            const idx = this._populateFullChanges[response.storageKey].requestIds.indexOf(response.id);
-            if (idx !== -1) {
-                this._populateFullChanges[response.storageKey].requestIds.splice(idx, 1);
-                this._populateFullChanges[response.storageKey].entities[response.id] = response.entity;
-                // If there are no request ids remaining we can complete the population
-                if (this._populateFullChanges[response.storageKey].requestIds.length === 0) {
-                    await this._populateFullChanges[response.storageKey].completeCallback();
-                }
-            }
-        }
-    }
-}
-
-/**
- * Class for performing synchronised storage operations.
- */
-class SynchronisedStorageService {
-    /**
-     * The default interval to check for entity updates.
-     * @internal
-     */
-    static _DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES = 5;
-    /**
-     * The default interval to perform consolidation.
-     * @internal
-     */
-    static _DEFAULT_CONSOLIDATION_INTERVAL_MINUTES = 60;
-    /**
-     * The default size of a consolidation batch.
-     * @internal
-     */
-    static _DEFAULT_CONSOLIDATION_BATCH_SIZE = 100;
-    /**
-     * The default max number of consolidations to keep in storage.
-     * @internal
-     */
-    static _DEFAULT_MAX_CONSOLIDATIONS = 5;
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "SynchronisedStorageService";
-    /**
-     * The logging component to use for logging.
-     * @internal
-     */
-    _loggingComponent;
-    /**
-     * The event bus component.
-     * @internal
-     */
-    _eventBusComponent;
-    /**
-     * The vault connector.
-     * @internal
-     */
-    _vaultConnector;
-    /**
-     * The storage connector for the sync snapshot entries.
-     * @internal
-     */
-    _localSyncSnapshotEntryEntityStorage;
-    /**
-     * The blob storage connector to use for remote sync states.
-     * @internal
-     */
-    _blobStorageConnector;
-    /**
-     * The verifiable storage connector to use for storing sync pointers.
-     * @internal
-     */
-    _verifiableSyncPointerStorageConnector;
-    /**
-     * The identity connector to use for signing/verifying changesets.
-     * @internal
-     */
-    _identityConnector;
-    /**
-     * The task scheduler component.
-     * @internal
-     */
-    _taskSchedulerComponent;
-    /**
-     * The synchronised storage service to use when this is not a trusted node.
-     * @internal
-     */
-    _trustedSynchronisedStorageComponent;
-    /**
-     * The blob storage helper.
-     * @internal
-     */
-    _blobStorageHelper;
-    /**
-     * The change set helper.
-     * @internal
-     */
-    _changeSetHelper;
-    /**
-     * The local sync state helper to use for applying changesets.
-     * @internal
-     */
-    _localSyncStateHelper;
-    /**
-     * The remote sync state helper to use for applying changesets.
-     * @internal
-     */
-    _remoteSyncStateHelper;
-    /**
-     * The options for the connector.
-     * @internal
-     */
-    _config;
-    /**
-     * The synchronised storage key to use for the remote synchronised storage.
-     * @internal
-     */
-    _synchronisedStorageKey;
-    /**
-     * The flag to determine if the service has been started.
-     * @internal
-     */
-    _serviceStarted;
-    /**
-     * The active storage keys for the synchronised storage service.
-     * @internal
-     */
-    _activeStorageKeys;
-    /**
-     * The identity of the node this connector is running on.
-     * @internal
-     */
-    _nodeIdentity;
-    /**
-     * Create a new instance of SynchronisedStorageService.
-     * @param options The options for the service.
-     */
-    constructor(options) {
-        Guards.object(this.CLASS_NAME, "options", options);
-        Guards.object(this.CLASS_NAME, "options.config", options.config);
-        Guards.stringValue(this.CLASS_NAME, "options.config.verifiableStorageKeyId", options.config.verifiableStorageKeyId);
-        this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType ?? "event-bus");
-        this._loggingComponent = ComponentFactory.getIfExists(options.loggingComponentType ?? "logging");
-        this._vaultConnector = VaultConnectorFactory.get(options.vaultConnectorType ?? "vault");
-        this._localSyncSnapshotEntryEntityStorage = EntityStorageConnectorFactory.get(options.syncSnapshotStorageConnectorType ?? "sync-snapshot-entry");
-        this._verifiableSyncPointerStorageConnector = VerifiableStorageConnectorFactory.get(options.verifiableStorageConnectorType ?? "verifiable-storage");
-        this._blobStorageConnector = BlobStorageConnectorFactory.get(options.blobStorageConnectorType ?? "blob-storage");
-        this._identityConnector = IdentityConnectorFactory.get(options.identityConnectorType ?? "identity");
-        this._taskSchedulerComponent = ComponentFactory.get(options.taskSchedulerComponentType ?? "task-scheduler");
-        // If this is empty we assume the local node has the rights to write to the verifiable storage.
-        let isTrustedNode = true;
-        if (!Is.empty(options.trustedSynchronisedStorageComponentType)) {
-            isTrustedNode = false;
-            // If it is set then we used the trusted component to send changesets to
-            this._trustedSynchronisedStorageComponent =
-                ComponentFactory.get(options.trustedSynchronisedStorageComponentType);
-        }
-        this._config = {
-            synchronisedStorageMethodId: options.config.synchronisedStorageMethodId ?? "synchronised-storage-assertion",
-            entityUpdateIntervalMinutes: options.config.entityUpdateIntervalMinutes ??
-                SynchronisedStorageService._DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES,
-            consolidationIntervalMinutes: options.config.consolidationIntervalMinutes ??
-                SynchronisedStorageService._DEFAULT_CONSOLIDATION_INTERVAL_MINUTES,
-            consolidationBatchSize: options.config.consolidationBatchSize ??
-                SynchronisedStorageService._DEFAULT_CONSOLIDATION_BATCH_SIZE,
-            maxConsolidations: options.config.maxConsolidations ?? SynchronisedStorageService._DEFAULT_MAX_CONSOLIDATIONS,
-            blobStorageEncryptionKeyId: options.config.blobStorageEncryptionKeyId ?? "synchronised-storage-blob-encryption-key",
-            verifiableStorageKeyId: options.config.verifiableStorageKeyId
-        };
-        this._synchronisedStorageKey =
-            verifiableStorageKeys[options.config.verifiableStorageKeyId] ?? options.config.verifiableStorageKeyId;
-        Guards.stringValue(this.CLASS_NAME, "synchronisedStorageKey", this._synchronisedStorageKey);
-        this._blobStorageHelper = new BlobStorageHelper(this._loggingComponent, this._vaultConnector, this._blobStorageConnector, this._config.blobStorageEncryptionKeyId, isTrustedNode);
-        this._changeSetHelper = new ChangeSetHelper(this._loggingComponent, this._eventBusComponent, this._identityConnector, this._blobStorageHelper, this._config.synchronisedStorageMethodId);
-        this._localSyncStateHelper = new LocalSyncStateHelper(this._loggingComponent, this._localSyncSnapshotEntryEntityStorage, this._changeSetHelper);
-        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._loggingComponent, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, isTrustedNode, this._config.maxConsolidations);
-        this._serviceStarted = false;
-        this._activeStorageKeys = {};
-        this._eventBusComponent.subscribe(SynchronisedStorageTopics.RegisterStorageKey, async (event) => this.registerStorageKey(event.data));
-        this._eventBusComponent.subscribe(SynchronisedStorageTopics.LocalItemChange, async (event) => {
-            // Make sure the change event is from this node
-            if (Is.stringValue(this._nodeIdentity) && this._nodeIdentity === event.data.nodeIdentity) {
-                await this._localSyncStateHelper.addLocalChange(event.data.storageKey, event.data.operation, event.data.id);
-            }
-        });
-    }
-    /**
-     * The component needs to be started when the node is initialized.
-     * @param nodeIdentity The identity of the node starting the component.
-     * @param nodeLoggingConnectorType The node logging connector type, defaults to "node-logging".
-     * @param componentState A persistent state which can be modified by the method.
-     * @returns Nothing.
-     */
-    async start(nodeIdentity, nodeLoggingConnectorType, componentState) {
-        this._nodeIdentity = nodeIdentity;
-        this._remoteSyncStateHelper.setNodeIdentity(nodeIdentity);
-        this._changeSetHelper.setNodeIdentity(nodeIdentity);
-        this._remoteSyncStateHelper.setSynchronisedStorageKey(this._synchronisedStorageKey);
-        this._serviceStarted = true;
-        // If this is not a trusted node we need to request the decryption key from a trusted node
-        if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
-            const proof = await this._identityConnector.createProof(this._nodeIdentity, DocumentHelper.joinId(this._nodeIdentity, this._config.synchronisedStorageMethodId), ProofTypes.DataIntegrityProof, { nodeIdentity });
-            const decryptionKey = await this._trustedSynchronisedStorageComponent.getDecryptionKey(this._nodeIdentity, proof);
-            // We don't have the private key so instead we store the key as a secret in the vault
-            await this._vaultConnector.setSecret(this._config.blobStorageEncryptionKeyId, decryptionKey);
-        }
-        // If there are already storage keys registered, we need to activate them
-        for (const storageKey in this._activeStorageKeys) {
-            await this.activateStorageKey(storageKey);
-        }
-    }
-    /**
-     * The component needs to be stopped when the node is closed.
-     * @param nodeIdentity The identity of the node stopping the component.
-     * @param nodeLoggingConnectorType The node logging connector type, defaults to "node-logging".
-     * @param componentState A persistent state which can be modified by the method.
-     * @returns Nothing.
-     */
-    async stop(nodeIdentity, nodeLoggingConnectorType, componentState) {
-        for (const storageKey in this._activeStorageKeys) {
-            this._activeStorageKeys[storageKey] = false;
-            this._taskSchedulerComponent.removeTask(`synchronised-storage-update-${storageKey}`);
-            this._taskSchedulerComponent.removeTask(`synchronised-storage-consolidation-${storageKey}`);
-        }
-    }
-    /**
-     * Get the decryption key for the synchronised storage.
-     * This is used to decrypt the data stored in the synchronised storage.
-     * @param nodeIdentity The identity of the node requesting the decryption key.
-     * @param proof The proof of the request so we know the request is from the specified node.
-     * @returns The decryption key.
-     */
-    async getDecryptionKey(nodeIdentity, proof) {
-        if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
-            throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
-        }
-        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        Guards.object(this.CLASS_NAME, "proof", proof);
-        const isValid = await this._identityConnector.verifyProof({ nodeIdentity }, proof);
-        if (!isValid) {
-            throw new UnauthorizedError(this.CLASS_NAME, "invalidProof");
-        }
-        // TODO: We need to check if the node has permissions to access the decryption key
-        // using rights-management
-        const key = await this._vaultConnector.getKey(this._config.blobStorageEncryptionKeyId);
-        if (Is.undefined(key.publicKey)) {
-            throw new UnauthorizedError(this.CLASS_NAME, "decryptionKeyNotFound");
-        }
-        return Converter.bytesToBase64(key.publicKey);
-    }
-    /**
-     * Synchronise a set of changes from an untrusted node, assumes this is a trusted node.
-     * @param syncChangeSet The change set to synchronise.
-     * @returns Nothing.
-     */
-    async syncChangeSet(syncChangeSet) {
-        if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
-            throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
-        }
-        Guards.object(this.CLASS_NAME, "syncChangeSet", syncChangeSet);
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "syncChangeSetForRemoteNode",
-            data: {
-                changeSetStorageId: syncChangeSet.id
-            }
-        });
-        // TODO: The change set has a proof signed by the originating node identity
-        // The proof is verified that the change set is valid and has not been tampered with.
-        // but we also need to check that the originating node has permissions
-        // to store the change set in the synchronised storage.
-        // This will be performed using rights-management
-        const copy = await this._changeSetHelper.copyChangeset(syncChangeSet);
-        if (!Is.empty(copy)) {
-            // Apply the changes to this node
-            await this._changeSetHelper.applyChangeset(copy.syncChangeSet);
-            // And update the sync state with the latest changes
-            await this._remoteSyncStateHelper.addChangeSetToSyncState(copy.syncChangeSet.storageKey, copy.changeSetStorageId);
-        }
-    }
-    /**
-     * Start the sync with further updates after an interval.
-     * @param storageKey The storage key to sync.
-     * @returns Nothing.
-     * @internal
-     */
-    async startEntitySync(storageKey) {
-        try {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "startEntitySync",
-                data: {
-                    storageKey
-                }
-            });
-            // First we check for remote changes
-            await this.updateFromRemoteSyncState(storageKey);
-            // Now send any updates we have to the remote storage
-            await this.updateFromLocalSyncState(storageKey);
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "entitySyncFailed",
-                error: BaseError.fromError(error)
-            });
-        }
-    }
-    /**
-     * Check for updates in the remote storage.
-     * @param storageKey The storage key to check for updates.
-     * @returns Nothing.
-     * @internal
-     */
-    async updateFromRemoteSyncState(storageKey) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "updateFromRemoteSyncState",
-            data: {
-                storageKey
-            }
-        });
-        // Get the verifiable sync pointer store from the verifiable storage
-        const verifiableSyncPointerStore = await this._remoteSyncStateHelper.getVerifiableSyncPointerStore();
-        if (!Is.empty(verifiableSyncPointerStore.syncPointers[storageKey])) {
-            // Load the sync state from the remote blob storage using the sync pointer
-            // to load the sync state
-            const remoteSyncState = await this._remoteSyncStateHelper.getSyncState(verifiableSyncPointerStore.syncPointers[storageKey]);
-            // If we got the sync state we can try and sync from it
-            if (!Is.undefined(remoteSyncState)) {
-                await this._localSyncStateHelper.applySyncState(storageKey, remoteSyncState);
-            }
-        }
-    }
-    /**
-     * Find any local updates and send them to the remote storage.
-     * @returns Nothing.
-     * @internal
-     */
-    async updateFromLocalSyncState(storageKey) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "updateFromLocalSyncState",
-            data: {
-                storageKey
-            }
-        });
-        const localChangeSnapshots = await this._localSyncStateHelper.getSnapshots(storageKey, true);
-        if (localChangeSnapshots.length > 0) {
-            const localChangeSnapshot = localChangeSnapshots[0];
-            if (Is.arrayValue(localChangeSnapshot.changes)) {
-                await this._remoteSyncStateHelper.buildChangeSet(storageKey, localChangeSnapshot.changes, async (syncChangeSet, changeSetStorageId) => {
-                    if (Is.empty(syncChangeSet) && Is.empty(changeSetStorageId)) {
-                        await this._loggingComponent?.log({
-                            level: "info",
-                            source: this.CLASS_NAME,
-                            message: "builtStorageChangeSetNone",
-                            data: {
-                                storageKey
-                            }
-                        });
-                    }
-                    else {
-                        await this._loggingComponent?.log({
-                            level: "info",
-                            source: this.CLASS_NAME,
-                            message: "builtStorageChangeSet",
-                            data: {
-                                storageKey,
-                                changeSetStorageId
-                            }
-                        });
-                        // Send the local changes to the remote storage if we are a trusted node
-                        if (Is.empty(this._trustedSynchronisedStorageComponent) &&
-                            Is.stringValue(changeSetStorageId)) {
-                            // If we are a trusted node, we can add the change set to the sync state
-                            // and remove the local change snapshot
-                            await this._remoteSyncStateHelper.addChangeSetToSyncState(storageKey, changeSetStorageId);
-                            await this._localSyncStateHelper.removeLocalChangeSnapshot(localChangeSnapshot);
-                        }
-                        else if (!Is.empty(this._trustedSynchronisedStorageComponent) &&
-                            Is.object(syncChangeSet)) {
-                            // If we are not a trusted node, we need to send the changes to the trusted node
-                            // and then remove the local change snapshot
-                            await this._loggingComponent?.log({
-                                level: "info",
-                                source: this.CLASS_NAME,
-                                message: "sendingChangeSetToTrustedNode",
-                                data: {
-                                    storageKey,
-                                    changeSetStorageId
-                                }
-                            });
-                            await this._trustedSynchronisedStorageComponent.syncChangeSet(syncChangeSet);
-                            await this._localSyncStateHelper.removeLocalChangeSnapshot(localChangeSnapshot);
-                        }
-                    }
-                });
-            }
-            else {
-                await this._loggingComponent?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    message: "updateFromLocalSyncStateNoChanges",
-                    data: {
-                        storageKey
-                    }
-                });
-            }
-        }
-    }
-    /**
-     * Start the consolidation sync.
-     * @param storageKey The storage key to consolidate.
-     * @returns Nothing.
-     * @internal
-     */
-    async startConsolidationSync(storageKey) {
-        try {
-            // If we are going to perform a consolidation first take any local updates
-            // we have and create a changeset from them, so that anybody applying
-            // just changes since a consolidation can use the changeset
-            // and skip the consolidation
-            await this.updateFromLocalSyncState(storageKey);
-            // Now start the consolidation
-            await this._remoteSyncStateHelper.consolidationStart(storageKey, this._config.consolidationBatchSize ??
-                SynchronisedStorageService._DEFAULT_CONSOLIDATION_BATCH_SIZE);
-        }
-        catch (error) {
-            await this._loggingComponent?.log({
-                level: "error",
-                source: this.CLASS_NAME,
-                message: "consolidationSyncFailed",
-                error: BaseError.fromError(error)
-            });
-        }
-    }
-    /**
-     * Register a new sync type.
-     * @param syncRegisterStorageKey The sync register type to register.
-     * @internal
-     */
-    async registerStorageKey(syncRegisterStorageKey) {
-        await this._loggingComponent?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "registerStorageKey",
-            data: {
-                storageKey: syncRegisterStorageKey.storageKey
-            }
-        });
-        if (Is.empty(this._activeStorageKeys[syncRegisterStorageKey.storageKey])) {
-            this._activeStorageKeys[syncRegisterStorageKey.storageKey] = false;
-            if (this._serviceStarted) {
-                await this.activateStorageKey(syncRegisterStorageKey.storageKey);
-            }
-        }
-    }
-    /**
-     * Activate a storage key.
-     * @param storageKey The storage key to activate.
-     * @internal
-     */
-    async activateStorageKey(storageKey) {
-        if (!Is.empty(this._activeStorageKeys[storageKey]) && !this._activeStorageKeys[storageKey]) {
-            await this._loggingComponent?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "activateStorageKey",
-                data: {
-                    storageKey
-                }
-            });
-            this._activeStorageKeys[storageKey] = true;
-            if (this._config.entityUpdateIntervalMinutes > 0) {
-                await this._taskSchedulerComponent.addTask(`synchronised-storage-update-${storageKey}`, [
-                    {
-                        nextTriggerTime: Date.now(),
-                        intervalMinutes: this._config.entityUpdateIntervalMinutes
-                    }
-                ], async () => this.startEntitySync(storageKey));
-            }
-            if (!Is.empty(this._trustedSynchronisedStorageComponent) &&
-                this._config.consolidationIntervalMinutes > 0) {
-                await this._taskSchedulerComponent.addTask(`synchronised-storage-consolidation-${storageKey}`, [
-                    {
-                        nextTriggerTime: Date.now(),
-                        intervalMinutes: this._config.consolidationIntervalMinutes
-                    }
-                ], async () => this.startConsolidationSync(storageKey));
-            }
-        }
-    }
-}
-
-export { SyncSnapshotEntry, SynchronisedStorageService, generateRestRoutesSynchronisedStorage, initSchema, restEntryPoints, synchronisedStorageGetDecryptionKeyRequest, synchronisedStorageSyncChangeSetRequest, tagsSynchronisedStorage };