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

package/dist/esm/index.mjs

@@ -1,13 +1,15 @@
 import { property, entity, EntitySchemaFactory, EntitySchemaHelper, ComparisonOperator } from '@twin.org/entity';
-import { Guards, ComponentFactory, Is, ObjectHelper, Converter, RandomHelper, BaseError, NotFoundError, GeneralError } from '@twin.org/core';
+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 { LoggingConnectorFactory } from '@twin.org/logging-models';
+import { ProofTypes } from '@twin.org/standards-w3c-did';
 import { SyncChangeOperation, SynchronisedStorageTopics } from '@twin.org/synchronised-storage-models';
+import { VaultEncryptionType, VaultConnectorFactory } from '@twin.org/vault-models';
 import { VerifiableStorageConnectorFactory } from '@twin.org/verifiable-storage-models';
-import { BlobStorageCompressionType } from '@twin.org/blob-storage-models';
-import { ProofTypes } from '@twin.org/standards-w3c-did';
+import { RSA } from '@twin.org/crypto';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -20,9 +22,9 @@ let SyncSnapshotEntry = class SyncSnapshotEntry {
      */
     id;
     /**
-     * The schema type for the snapshot i.e. which entity is being synchronized.
+     * The storage key for the snapshot i.e. which entity is being synchronized.
      */
-    schemaType;
+    storageKey;
     /**
      * The date the snapshot was created.
      */
@@ -42,7 +44,7 @@ let SyncSnapshotEntry = class SyncSnapshotEntry {
     /**
      * The changes that were made in this snapshot, if this is a local snapshot.
      */
-    localChanges;
+    changes;
 };
 __decorate([
     property({ type: "string", isPrimary: true }),
@@ -51,7 +53,7 @@ __decorate([
 __decorate([
     property({ type: "string", isSecondary: true }),
     __metadata("design:type", String)
-], SyncSnapshotEntry.prototype, "schemaType", void 0);
+], SyncSnapshotEntry.prototype, "storageKey", void 0);
 __decorate([
     property({ type: "string" }),
     __metadata("design:type", String)
@@ -71,7 +73,7 @@ __decorate([
 __decorate([
     property({ type: "array", itemType: "object", optional: true }),
     __metadata("design:type", Array)
-], SyncSnapshotEntry.prototype, "localChanges", void 0);
+], SyncSnapshotEntry.prototype, "changes", void 0);
 SyncSnapshotEntry = __decorate([
     entity()
 ], SyncSnapshotEntry);
@@ -100,8 +102,8 @@ function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
         operationId: "synchronisedStorageSyncChangeSetRequest",
         summary: "Request that the node perform a sync request for a changeset.",
         tag: tagsSynchronisedStorage[0].name,
-        method: "GET",
-        path: `${baseRouteName}/`,
+        method: "POST",
+        path: `${baseRouteName}/sync-changeset`,
         handler: async (httpRequestContext, request) => synchronisedStorageSyncChangeSetRequest(httpRequestContext, componentName, request),
         requestType: {
             type: "ISyncChangeSetRequest",
@@ -109,8 +111,29 @@ function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
                 {
                     id: "synchronisedStorageSyncChangeSetRequestExample",
                     request: {
-                        query: {
-                            changeSetStorageId: "12345"
+                        body: {
+                            id: "0909090909090909090909090909090909090909090909090909090909090909",
+                            dateCreated: "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"
                         }
                     }
                 }
@@ -120,9 +143,61 @@ function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
             {
                 type: "INoContentResponse"
             }
-        ]
+        ],
+        // Authentication is provided by the proof in the request body.
+        skipAuth: true
     };
-    return [syncChangeSetRoute];
+    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.
@@ -133,13 +208,31 @@ function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
  */
 async function synchronisedStorageSyncChangeSetRequest(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    Guards.object(ROUTES_SOURCE, "request.body", request.body);
     const component = ComponentFactory.get(componentName);
-    await component.syncChangeSet(request.query.changeSetStorageId);
+    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 = [
     {
@@ -159,6 +252,163 @@ function initSchema() {
     EntitySchemaFactory.register("SyncSnapshotEntry", () => EntitySchemaHelper.getSchema(SyncSnapshotEntry));
 }
 
+var mainnet = "";
+var testnet = "";
+var devnet = "";
+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 connector to use for logging.
+     * @internal
+     */
+    _logging;
+    /**
+     * 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 logging 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(logging, vaultConnector, blobStorageConnector, blobStorageEncryptionKeyId, isTrustedNode) {
+        this._logging = logging;
+        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 load(blobId) {
+        await this._logging?.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._logging?.log({
+                    level: "info",
+                    source: this.CLASS_NAME,
+                    message: "loadedBlob",
+                    data: {
+                        blobId
+                    }
+                });
+                return ObjectHelper.fromBytes(decompressedBlob);
+            }
+        }
+        catch (error) {
+            await this._logging?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                message: "loadBlobFailed",
+                data: {
+                    blobId
+                },
+                error: BaseError.fromError(error)
+            });
+        }
+        await this._logging?.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._logging?.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._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                message: "savedBlob",
+                data: {
+                    blobId
+                }
+            });
+            return blobId;
+        }
+        catch (error) {
+            await this._logging?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                message: "saveBlobFailed",
+                error: BaseError.fromError(error)
+            });
+            throw error;
+        }
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -180,10 +430,10 @@ class ChangeSetHelper {
      */
     _eventBusComponent;
     /**
-     * The blob storage component to use for remote sync states.
+     * The blob storage helper to use for remote sync states.
      * @internal
      */
-    _blobStorageComponent;
+    _blobStorageHelper;
     /**
      * The identity connector to use for signing/verifying changesets.
      * @internal
@@ -194,50 +444,85 @@ class ChangeSetHelper {
      * @internal
      */
     _decentralisedStorageMethodId;
+    /**
+     * The identity of the node that is performing the update.
+     * @internal
+     */
+    _nodeIdentity;
     /**
      * Create a new instance of ChangeSetHelper.
      * @param logging The logging connector to use for logging.
      * @param eventBusComponent The event bus component to use for events.
-     * @param blobStorageComponent The blob storage component to use for remote sync states.
      * @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(logging, eventBusComponent, blobStorageComponent, identityConnector, decentralisedStorageMethodId) {
+    constructor(logging, eventBusComponent, identityConnector, blobStorageHelper, decentralisedStorageMethodId) {
         this._logging = logging;
         this._eventBusComponent = eventBusComponent;
         this._decentralisedStorageMethodId = decentralisedStorageMethodId;
-        this._blobStorageComponent = blobStorageComponent;
+        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) {
-        // Changesets are not encrypted as they are signed with the node identity
-        // and they are publicly accessible so that other nodes can retrieve them.
-        const blobEntry = await this._blobStorageComponent.get(changeSetStorageId, {
-            includeContent: true
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "getChangeSet",
+            data: {
+                changeSetStorageId
+            }
         });
-        if (Is.stringBase64(blobEntry.blob)) {
-            const syncChangeset = ObjectHelper.fromBytes(Converter.base64ToBytes(blobEntry.blob));
-            const verified = await this.verifyChangesetProof(syncChangeset);
-            return verified ? syncChangeset : undefined;
+        try {
+            const syncChangeSet = await this._blobStorageHelper.load(changeSetStorageId);
+            if (Is.object(syncChangeSet)) {
+                const verified = await this.verifyChangesetProof(syncChangeSet);
+                return verified ? syncChangeSet : undefined;
+            }
+        }
+        catch (error) {
+            await this._logging?.log({
+                level: "warn",
+                source: this.CLASS_NAME,
+                message: "getChangeSetError",
+                data: {
+                    changeSetStorageId
+                },
+                error: BaseError.fromError(error)
+            });
         }
+        await this._logging?.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 True if the change was applied.
+     * @returns The changeset if it existed.
      */
     async getAndApplyChangeset(changeSetStorageId) {
         const syncChangeset = await this.getAndVerifyChangeset(changeSetStorageId);
         if (!Is.empty(syncChangeset)) {
             await this.applyChangeset(syncChangeset);
-            return true;
         }
-        return false;
+        return syncChangeset;
     }
     /**
      * Apply a sync changeset.
@@ -259,20 +544,25 @@ class ChangeSetHelper {
                 switch (change.operation) {
                     case SyncChangeOperation.Set:
                         if (!Is.empty(change.entity)) {
-                            // The node identity was stripped when stored in the changeset
+                            // 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.
-                            change.entity.nodeIdentity = syncChangeset.nodeIdentity;
                             await this._eventBusComponent.publish(SynchronisedStorageTopics.RemoteItemSet, {
-                                schemaType: syncChangeset.schemaType,
-                                entity: change.entity
+                                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, {
-                                schemaType: syncChangeset.schemaType,
+                                storageKey: syncChangeset.storageKey,
                                 id: change.id
                             });
                         }
@@ -295,12 +585,7 @@ class ChangeSetHelper {
                 id: syncChangeSet.id
             }
         });
-        // We don't want to encrypt the sync state as no other nodes would be able to read it
-        // the blob storage also needs to be publicly accessible so that other nodes can retrieve it
-        return this._blobStorageComponent.create(Converter.bytesToBase64(ObjectHelper.toBytes(syncChangeSet)), undefined, undefined, undefined, {
-            disableEncryption: true,
-            compress: BlobStorageCompressionType.Gzip
-        });
+        return this._blobStorageHelper.saveBlob(syncChangeSet);
     }
     /**
      * Verify the proof of a sync changeset.
@@ -319,6 +604,32 @@ class ChangeSetHelper {
             });
             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._logging?.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._logging?.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);
@@ -350,11 +661,12 @@ class ChangeSetHelper {
      * @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(syncChangeset.nodeIdentity, DocumentHelper.joinId(syncChangeset.nodeIdentity, this._decentralisedStorageMethodId), ProofTypes.DataIntegrityProof, changeSetWithoutProof);
+        const proof = await this._identityConnector.createProof(this._nodeIdentity, DocumentHelper.joinId(this._nodeIdentity, this._decentralisedStorageMethodId), ProofTypes.DataIntegrityProof, changeSetWithoutProof);
         await this._logging?.log({
-            level: "error",
+            level: "info",
             source: this.CLASS_NAME,
             message: "createdChangeSetProof",
             data: {
@@ -364,6 +676,35 @@ class ChangeSetHelper {
         });
         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._logging?.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)
+                };
+            }
+        }
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -385,7 +726,7 @@ class LocalSyncStateHelper {
      * The storage connector for the sync snapshot entries.
      * @internal
      */
-    _localSyncSnapshotEntryEntityStorage;
+    _snapshotEntryEntityStorage;
     /**
      * The change set helper to use for applying changesets.
      * @internal
@@ -394,44 +735,62 @@ class LocalSyncStateHelper {
     /**
      * Create a new instance of LocalSyncStateHelper.
      * @param logging The logging connector to use for logging.
-     * @param localSyncSnapshotEntryEntityStorage The storage connector for the local sync snapshot entries.
+     * @param snapshotEntryEntityStorage The storage connector for the sync snapshot entries.
      * @param changeSetHelper The change set helper to use for applying changesets.
      */
-    constructor(logging, localSyncSnapshotEntryEntityStorage, changeSetHelper) {
+    constructor(logging, snapshotEntryEntityStorage, changeSetHelper) {
         this._logging = logging;
-        this._localSyncSnapshotEntryEntityStorage = localSyncSnapshotEntryEntityStorage;
+        this._snapshotEntryEntityStorage = snapshotEntryEntityStorage;
         this._changeSetHelper = changeSetHelper;
     }
     /**
      * Add a new change to the local snapshot.
-     * @param schemaType The schema type of the snapshot to add the change for.
+     * @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(schemaType, operation, id) {
-        const localChangeSnapshot = await this.getLocalChangeSnapshot(schemaType);
-        localChangeSnapshot.localChanges ??= [];
+    async addLocalChange(storageKey, operation, id) {
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "addLocalChange",
+            data: {
+                storageKey,
+                operation,
+                id
+            }
+        });
+        const localChangeSnapshot = await this.getLocalChangeSnapshot(storageKey);
+        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.localChanges.findIndex(change => change.id === id);
+        const previousChangeIndex = localChangeSnapshot.changes.findIndex(change => change.id === id);
         if (previousChangeIndex !== -1) {
-            localChangeSnapshot.localChanges.splice(previousChangeIndex, 1);
+            localChangeSnapshot.changes.splice(previousChangeIndex, 1);
         }
-        if (localChangeSnapshot.localChanges.length > 0) {
+        if (localChangeSnapshot.changes.length > 0) {
             localChangeSnapshot.dateModified = new Date(Date.now()).toISOString();
         }
-        localChangeSnapshot.localChanges.push({ operation, id });
+        localChangeSnapshot.changes.push({ operation, id });
         await this.setLocalChangeSnapshot(localChangeSnapshot);
     }
     /**
-     * Get the current local snapshot.
-     * @param schemaType The schema type of the snapshot to get.
+     * Get the current local snapshot which contains just the changes for this node.
+     * @param storageKey The storage key of the snapshot to get.
      * @returns The local snapshot entry.
      */
-    async getLocalChangeSnapshot(schemaType) {
-        const queryResult = await this._localSyncSnapshotEntryEntityStorage.query({
+    async getLocalChangeSnapshot(storageKey) {
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "getLocalChangeSnapshot",
+            data: {
+                storageKey
+            }
+        });
+        const queryResult = await this._snapshotEntryEntityStorage.query({
             conditions: [
                 {
                     property: "isLocalSnapshot",
@@ -439,33 +798,57 @@ class LocalSyncStateHelper {
                     comparison: ComparisonOperator.Equals
                 },
                 {
-                    property: "schemaType",
-                    value: schemaType,
+                    property: "storageKey",
+                    value: storageKey,
                     comparison: ComparisonOperator.Equals
                 }
             ]
         });
         if (queryResult.entities.length > 0) {
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                message: "localChangeSnapshotExists",
+                data: {
+                    storageKey
+                }
+            });
             return queryResult.entities[0];
         }
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "localChangeSnapshotDoesNotExist",
+            data: {
+                storageKey
+            }
+        });
         return {
             id: Converter.bytesToHex(RandomHelper.generate(32)),
-            schemaType,
+            storageKey,
             dateCreated: new Date(Date.now()).toISOString(),
             changeSetStorageIds: [],
             isLocalSnapshot: true
         };
     }
     /**
-     * Set the current local snapshot.
+     * 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._localSyncSnapshotEntryEntityStorage.set(localChangeSnapshot);
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "setLocalChangeSnapshot",
+            data: {
+                storageKey: localChangeSnapshot.storageKey
+            }
+        });
+        await this._snapshotEntryEntityStorage.set(localChangeSnapshot);
     }
     /**
-     * Get the current local snapshot.
+     * Get the current local snapshot with the changes for this node.
      * @param localChangeSnapshot The local change snapshot to remove.
      * @returns Nothing.
      */
@@ -478,47 +861,47 @@ class LocalSyncStateHelper {
                 snapshotId: localChangeSnapshot.id
             }
         });
-        await this._localSyncSnapshotEntryEntityStorage.remove(localChangeSnapshot.id);
+        await this._snapshotEntryEntityStorage.remove(localChangeSnapshot.id);
     }
     /**
-     * Sync local data using a remote sync state.
-     * @param schemaType The schema type of the snapshot to sync with.
-     * @param remoteSyncState The sync state to sync with.
+     * 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 syncFromRemote(schemaType, remoteSyncState) {
+    async applySyncState(storageKey, syncState) {
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
-            message: "remoteSyncSynchronisation",
+            message: "applySyncState",
             data: {
-                snapshotCount: remoteSyncState.snapshots.length
+                snapshotCount: syncState.snapshots.length
             }
         });
         // Sort from newest to oldest
-        const sortedRemoteSnapshots = remoteSyncState.snapshots.sort((a, b) => new Date(b.dateCreated).getTime() - new Date(a.dateCreated).getTime());
+        const sortedSnapshots = syncState.snapshots.sort((a, b) => new Date(b.dateCreated).getTime() - new Date(a.dateCreated).getTime());
         const newSnapshots = [];
         const modifiedSnapshots = [];
-        for (const remoteSnapshot of sortedRemoteSnapshots) {
+        for (const snapshot of sortedSnapshots) {
             await this._logging?.log({
                 level: "info",
                 source: this.CLASS_NAME,
-                message: "remoteSyncSnapshotProcessing",
+                message: "applySnapshot",
                 data: {
-                    snapshotId: remoteSnapshot.id,
-                    dateCreated: new Date(remoteSnapshot.dateCreated).toISOString()
+                    snapshotId: snapshot.id,
+                    dateCreated: new Date(snapshot.dateCreated).toISOString()
                 }
             });
-            const localSnapshot = await this._localSyncSnapshotEntryEntityStorage.get(remoteSnapshot.id);
+            const localSnapshot = await this._snapshotEntryEntityStorage.get(snapshot.id);
             const remoteSnapshotWithContext = {
-                ...remoteSnapshot,
-                schemaType
+                ...snapshot,
+                storageKey
             };
             if (Is.empty(localSnapshot)) {
                 // We don't have the snapshot locally, so we need to process it
                 newSnapshots.push(remoteSnapshotWithContext);
             }
-            else if (localSnapshot.dateModified !== remoteSnapshot.dateModified) {
+            else if (localSnapshot.dateModified !== snapshot.dateModified) {
                 // If the local snapshot has a different dateModified, we need to update it
                 modifiedSnapshots.push({
                     localSnapshot,
@@ -540,13 +923,14 @@ class LocalSyncStateHelper {
      * 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._logging?.log({
                 level: "info",
                 source: this.CLASS_NAME,
-                message: "remoteSyncSnapshotModified",
+                message: "processModifiedSnapshot",
                 data: {
                     snapshotId: modifiedSnapshot.remoteSnapshot.id,
                     localModified: new Date(modifiedSnapshot.localSnapshot.dateModified ??
@@ -565,20 +949,21 @@ class LocalSyncStateHelper {
                     }
                 }
             }
-            await this._localSyncSnapshotEntryEntityStorage.set(modifiedSnapshot.remoteSnapshot);
+            await this._snapshotEntryEntityStorage.set(modifiedSnapshot.remoteSnapshot);
         }
     }
     /**
      * 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._logging?.log({
                 level: "info",
                 source: this.CLASS_NAME,
-                message: "remoteSyncSnapshotNew",
+                message: "processNewSnapshot",
                 data: {
                     snapshotId: newSnapshot.id,
                     localModified: new Date(newSnapshot.dateCreated).toISOString()
@@ -590,11 +975,17 @@ class LocalSyncStateHelper {
                     await this._changeSetHelper.getAndApplyChangeset(storageId);
                 }
             }
-            await this._localSyncSnapshotEntryEntityStorage.set(newSnapshot);
+            await this._snapshotEntryEntityStorage.set(newSnapshot);
         }
     }
 }
 
+// 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.
 /**
@@ -616,10 +1007,10 @@ class RemoteSyncStateHelper {
      */
     _eventBusComponent;
     /**
-     * The blob storage component to use for remote sync states.
+     * The blob storage helper.
      * @internal
      */
-    _blobStorageComponent;
+    _blobStorageHelper;
     /**
      * The verifiable storage connector to use for storing sync pointers.
      * @internal
@@ -631,12 +1022,12 @@ class RemoteSyncStateHelper {
      */
     _changeSetHelper;
     /**
-     * The storage ids of the batch responses for each schema type.
+     * The storage ids of the batch responses for each storage key.
      * @internal
      */
     _batchResponseStorageIds;
     /**
-     * The full changes for each schema type.
+     * The full changes for each storage key.
      * @internal
      */
     _populateFullChanges;
@@ -650,22 +1041,27 @@ class RemoteSyncStateHelper {
      * @internal
      */
     _nodeIdentity;
+    /**
+     * Whether the node is trusted or not.
+     * @internal
+     */
+    _isTrustedNode;
     /**
      * Create a new instance of DecentralisedEntityStorageConnector.
      * @param logging The logging connector to use for logging.
      * @param eventBusComponent The event bus component to use for events.
-     * @param blobStorageComponent The blob storage component to use for remote sync states.
      * @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 synchronisedStorageKey The synchronised storage key to use for verified storage operations.
+     * @param isTrustedNode Whether the node is trusted or not.
      */
-    constructor(logging, eventBusComponent, blobStorageComponent, verifiableSyncPointerStorageConnector, changeSetHelper, synchronisedStorageKey) {
+    constructor(logging, eventBusComponent, verifiableSyncPointerStorageConnector, blobStorageHelper, changeSetHelper, isTrustedNode) {
         this._logging = logging;
         this._eventBusComponent = eventBusComponent;
-        this._blobStorageComponent = blobStorageComponent;
         this._verifiableSyncPointerStorageConnector = verifiableSyncPointerStorageConnector;
         this._changeSetHelper = changeSetHelper;
-        this._synchronisedStorageKey = synchronisedStorageKey;
+        this._blobStorageHelper = blobStorageHelper;
+        this._isTrustedNode = isTrustedNode;
         this._batchResponseStorageIds = {};
         this._populateFullChanges = {};
         this._eventBusComponent.subscribe(SynchronisedStorageTopics.BatchResponse, async (response) => {
@@ -683,72 +1079,119 @@ class RemoteSyncStateHelper {
         this._nodeIdentity = nodeIdentity;
     }
     /**
-     * Create and store a change set.
-     * @param schemaType The schema type of the change set.
+     * 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 createAndStoreChangeSet(schemaType, changes, completeCallback) {
-        if (Is.arrayValue(changes)) {
-            this._populateFullChanges[schemaType] = {
-                changes,
-                entities: {},
-                requestIds: [],
-                completeCallback: async () => this.finaliseFullChanges(schemaType, 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(schemaType, completeCallback);
-            }
-            else {
-                // Otherwise we need to request the full details for each change
-                this._populateFullChanges[schemaType].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
-                    this._eventBusComponent.publish(SynchronisedStorageTopics.LocalItemRequest, {
-                        schemaType,
-                        id: change.id
-                    });
-                }
+    async buildChangeSet(storageKey, changes, completeCallback) {
+        await this._logging?.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 {
-            await completeCallback();
+            // 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._logging?.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 schemaType The schema type of the 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(schemaType, completeCallback) {
+    async finaliseFullChanges(storageKey, completeCallback) {
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "finalisingSyncChanges",
+            data: {
+                storageKey
+            }
+        });
         if (Is.stringValue(this._nodeIdentity)) {
-            const changes = this._populateFullChanges[schemaType].changes;
+            const changes = this._populateFullChanges[storageKey].changes;
             for (const change of changes) {
-                change.entity = this._populateFullChanges[schemaType].entities[change.id] ?? change.entity;
+                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");
                 }
             }
-            // Add the changeset to the current snapshot
             const syncChangeSet = {
                 id: Converter.bytesToHex(RandomHelper.generate(32)),
                 dateCreated: new Date(Date.now()).toISOString(),
-                schemaType,
+                storageKey,
                 changes,
                 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);
-            await completeCallback(changeSetStorageId);
+            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._logging?.log({
+                    level: "error",
+                    source: this.CLASS_NAME,
+                    message: "finalisingSyncChangesFailed",
+                    data: {
+                        storageKey
+                    },
+                    error: BaseError.fromError(err)
+                });
+                await completeCallback();
+            }
         }
         else {
             await completeCallback();
@@ -756,122 +1199,138 @@ class RemoteSyncStateHelper {
     }
     /**
      * 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(changeSetStorageId) {
-        // First load the current sync state if there is one
-        const syncStatePointer = await this.getVerifiableSyncPointer();
+    async addChangeSetToSyncState(storageKey, changeSetStorageId) {
+        await this._logging?.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(syncStatePointer?.syncPointerId)) {
-            syncState = await this.getRemoteSyncState(syncStatePointer.syncPointerId);
+        if (!Is.empty(syncPointerStore.syncPointers[storageKey])) {
+            syncState = await this.getRemoteSyncState(syncPointerStore.syncPointers[storageKey]);
         }
         // No current sync state, so we create a new one
         if (Is.empty(syncState)) {
-            syncState = { snapshots: [] };
+            syncState = { version: SYNC_STATE_VERSION, 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 now = new Date(Date.now()).toISOString();
         if (Is.empty(currentSnapshot)) {
             currentSnapshot = {
+                version: SYNC_SNAPSHOT_VERSION,
                 id: Converter.bytesToHex(RandomHelper.generate(32)),
-                dateCreated: new Date(Date.now()).toISOString(),
+                dateCreated: now,
+                dateModified: now,
                 changeSetStorageIds: []
             };
             syncState.snapshots.push(currentSnapshot);
         }
         else {
             // Snapshot exists, we update the dateModified
-            currentSnapshot.dateModified = new Date(Date.now()).toISOString();
+            currentSnapshot.dateModified = now;
         }
         // Add the changeset storage id to the current snapshot
         currentSnapshot.changeSetStorageIds.push(changeSetStorageId);
         // Store the sync state in the blob storage
-        const syncStateId = await this.storeRemoteSyncState(syncState);
-        // Store the verifiable sync pointer in the verifiable storage
-        await this.storeVerifiableSyncPointer(syncStateId);
+        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 schemaType The schema type of the snapshot to create.
+     * @param storageKey The storage key of the snapshot to create.
      * @param batchSize The batch size to use for consolidation.
      * @returns Nothing.
      */
-    async consolidateFromLocal(schemaType, batchSize) {
+    async consolidationStart(storageKey, batchSize) {
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
             message: "consolidationStarting"
         });
-        await this._eventBusComponent.publish(SynchronisedStorageTopics.BatchRequest, { schemaType, batchSize });
+        // Perform a batch request to start the consolidation
+        await this._eventBusComponent.publish(SynchronisedStorageTopics.BatchRequest, { storageKey, batchSize });
     }
     /**
-     * Get the sync pointer.
-     * @returns The sync pointer.
+     * Get the sync pointer store.
+     * @returns The sync pointer store.
      */
-    async getVerifiableSyncPointer() {
-        try {
-            await this._logging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "verifiableSyncPointerRetrieving",
-                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);
+    async getVerifiableSyncPointerStore() {
+        if (Is.stringValue(this._synchronisedStorageKey)) {
+            try {
                 await this._logging?.log({
                     level: "info",
                     source: this.CLASS_NAME,
-                    message: "verifiableSyncPointerRetrieved",
+                    message: "verifiableSyncPointerStoreRetrieving",
                     data: {
-                        key: this._synchronisedStorageKey,
-                        syncPointerId: syncPointer.syncPointerId
+                        key: this._synchronisedStorageKey
                     }
                 });
-                return syncPointer;
+                const syncPointerStore = await this._verifiableSyncPointerStorageConnector.get(this._synchronisedStorageKey, { includeData: true });
+                if (Is.uint8Array(syncPointerStore.data)) {
+                    const syncPointer = ObjectHelper.fromBytes(syncPointerStore.data);
+                    await this._logging?.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;
+            catch (err) {
+                if (!BaseError.someErrorName(err, NotFoundError.CLASS_NAME)) {
+                    throw err;
+                }
             }
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                message: "verifiableSyncPointerStoreNotFound",
+                data: {
+                    key: this._synchronisedStorageKey
+                }
+            });
         }
-        await this._logging?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "verifiableSyncPointerNotFound",
-            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 syncStateId The id of the sync state to store.
+     * @param syncPointerStore The sync pointer store to store.
      * @returns Nothing.
      */
-    async storeVerifiableSyncPointer(syncStateId) {
-        // Create a new verifiable sync pointer object pointing to the sync state
-        const verifiableSyncPointer = {
-            syncPointerId: syncStateId
-        };
-        await this._logging?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            message: "verifiableSyncPointerStoring",
-            data: {
-                key: this._synchronisedStorageKey,
-                syncPointerId: verifiableSyncPointer.syncPointerId
-            }
-        });
-        // Store the verifiable sync pointer in the verifiable storage
-        await this._verifiableSyncPointerStorageConnector.create(this._synchronisedStorageKey, ObjectHelper.toBytes(verifiableSyncPointer));
-        return verifiableSyncPointer;
+    async storeVerifiableSyncPointerStore(syncPointerStore) {
+        if (Is.stringValue(this._nodeIdentity) && Is.stringValue(this._synchronisedStorageKey)) {
+            await this._logging?.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.
@@ -887,9 +1346,7 @@ class RemoteSyncStateHelper {
                 snapshotCount: syncState.snapshots.length
             }
         });
-        // We don't want to encrypt the sync state as no other nodes would be able to read it
-        // the blob storage also needs to be publicly accessible so that other nodes can retrieve it
-        return this._blobStorageComponent.create(Converter.bytesToBase64(ObjectHelper.toBytes(syncState)), undefined, undefined, undefined, { disableEncryption: true, compress: BlobStorageCompressionType.Gzip });
+        return this._blobStorageHelper.saveBlob(syncState);
     }
     /**
      * Get the remote sync state.
@@ -906,11 +1363,8 @@ class RemoteSyncStateHelper {
                     syncPointerId
                 }
             });
-            const blobEntry = await this._blobStorageComponent.get(syncPointerId, {
-                includeContent: true
-            });
-            if (Is.stringBase64(blobEntry.blob)) {
-                const syncState = ObjectHelper.fromBytes(Converter.base64ToBytes(blobEntry.blob));
+            const syncState = await this._blobStorageHelper.load(syncPointerId);
+            if (Is.object(syncState)) {
                 await this._logging?.log({
                     level: "info",
                     source: this.CLASS_NAME,
@@ -923,10 +1377,16 @@ class RemoteSyncStateHelper {
                 return syncState;
             }
         }
-        catch (err) {
-            if (!BaseError.someErrorName(err, NotFoundError.CLASS_NAME)) {
-                throw err;
-            }
+        catch (error) {
+            await this._logging?.log({
+                level: "warn",
+                source: this.CLASS_NAME,
+                message: "getSyncStateError",
+                data: {
+                    syncPointerId
+                },
+                error: BaseError.fromError(error)
+            });
         }
         await this._logging?.log({
             level: "info",
@@ -938,20 +1398,22 @@ class RemoteSyncStateHelper {
         });
     }
     /**
-     * Handle the batch response.
+     * 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: new Date(Date.now()).toISOString(),
+                dateCreated: now,
+                dateModified: now,
                 changes: response.entities.map(change => ({
                     operation: SyncChangeOperation.Set,
-                    id: change[response.primaryKey]
+                    id: change.id
                 })),
-                schemaType: response.schemaType,
+                storageKey: response.storageKey,
                 nodeIdentity: this._nodeIdentity
             };
             // And sign it with the node identity
@@ -959,20 +1421,35 @@ class RemoteSyncStateHelper {
             // 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.schemaType] ??= [];
-            this._batchResponseStorageIds[response.schemaType].push(changeSetStorageId);
+            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) {
-                const syncState = { snapshots: [] };
+                // 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.getRemoteSyncState(syncPointerStore.syncPointers[response.storageKey]);
+                }
+                // If the sync state does not exist, we create a new one
+                syncState ??= { version: SYNC_STATE_VERSION, snapshots: [] };
                 const batchSnapshot = {
+                    version: SYNC_SNAPSHOT_VERSION,
                     id: Converter.bytesToHex(RandomHelper.generate(32)),
-                    dateCreated: new Date(Date.now()).toISOString(),
-                    changeSetStorageIds: this._batchResponseStorageIds[response.schemaType]
+                    dateCreated: now,
+                    dateModified: now,
+                    changeSetStorageIds: this._batchResponseStorageIds[response.storageKey]
                 };
                 syncState.snapshots.push(batchSnapshot);
                 // Store the sync state in the blob storage
                 const syncStateId = await this.storeRemoteSyncState(syncState);
+                syncPointerStore.syncPointers[response.storageKey] = syncStateId;
                 // Store the verifiable sync pointer in the verifiable storage
-                await this.storeVerifiableSyncPointer(syncStateId);
+                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._logging?.log({
                     level: "info",
                     source: this.CLASS_NAME,
@@ -986,13 +1463,22 @@ class RemoteSyncStateHelper {
      * @param response The item response to handle.
      */
     async handleLocalItemResponse(response) {
-        if (!Is.empty(this._populateFullChanges[response.schemaType])) {
-            const idx = this._populateFullChanges[response.schemaType].requestIds.indexOf(response.id);
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "createChangeSetRespondingItem",
+            data: {
+                storageKey: response.storageKey,
+                id: response.id
+            }
+        });
+        if (!Is.empty(this._populateFullChanges[response.storageKey])) {
+            const idx = this._populateFullChanges[response.storageKey].requestIds.indexOf(response.id);
             if (idx !== -1) {
-                this._populateFullChanges[response.schemaType].requestIds.splice(idx, 1);
-                this._populateFullChanges[response.schemaType].entities[response.id] = response.entity;
-                if (this._populateFullChanges[response.schemaType].requestIds.length === 0) {
-                    await this._populateFullChanges[response.schemaType].completeCallback();
+                this._populateFullChanges[response.storageKey].requestIds.splice(idx, 1);
+                this._populateFullChanges[response.storageKey].entities[response.id] = response.entity;
+                if (this._populateFullChanges[response.storageKey].requestIds.length === 0) {
+                    await this._populateFullChanges[response.storageKey].completeCallback();
                 }
             }
         }
@@ -1004,20 +1490,20 @@ class RemoteSyncStateHelper {
  */
 class SynchronisedStorageService {
     /**
-     * The default interval to check for entity updates, defaults to 5 mins.
+     * The default interval to check for entity updates.
      * @internal
      */
-    static _DEFAULT_ENTITY_UPDATE_INTERVAL_MS = 300000;
+    static _DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES = 5;
     /**
-     * The default interval to perform consolidation, defaults to 60 mins.
+     * The default interval to perform consolidation.
      * @internal
      */
-    static _DEFAULT_CONSOLIDATION_INTERVAL_MS = 3600000;
+    static _DEFAULT_CONSOLIDATION_INTERVAL_MINUTES = 60;
     /**
      * The default size of a consolidation batch.
      * @internal
      */
-    static _DEFAULT_CONSOLIDATION_BATCH_SIZE = 1000;
+    static _DEFAULT_CONSOLIDATION_BATCH_SIZE = 100;
     /**
      * Runtime name for the class.
      */
@@ -1032,16 +1518,21 @@ class SynchronisedStorageService {
      * @internal
      */
     _eventBusComponent;
+    /**
+     * The vault connector.
+     * @internal
+     */
+    _vaultConnector;
     /**
      * The storage connector for the sync snapshot entries.
      * @internal
      */
     _localSyncSnapshotEntryEntityStorage;
     /**
-     * The blob storage component to use for remote sync states.
+     * The blob storage connector to use for remote sync states.
      * @internal
      */
-    _blobStorageComponent;
+    _blobStorageConnector;
     /**
      * The verifiable storage connector to use for storing sync pointers.
      * @internal
@@ -1052,11 +1543,21 @@ class SynchronisedStorageService {
      * @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
@@ -1078,15 +1579,20 @@ class SynchronisedStorageService {
      */
     _config;
     /**
-     * The timer ids for checking for entity updates.
+     * The synchronised storage key to use for the remote synchronised storage.
      * @internal
      */
-    _entityUpdateTimers;
+    _synchronisedStorageKey;
     /**
-     * The timer ids for consolidation.
+     * The flag to determine if the service has been started.
      * @internal
      */
-    _consolidationTimers;
+    _serviceStarted;
+    /**
+     * The active storage keys for the synchronised storage service.
+     * @internal
+     */
+    _activeStorageKeys;
     /**
      * The identity of the node this connector is running on.
      * @internal
@@ -1101,21 +1607,26 @@ class SynchronisedStorageService {
         Guards.object(this.CLASS_NAME, "options.config", options.config);
         this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType ?? "event-bus");
         this._logging = LoggingConnectorFactory.getIfExists(options.loggingConnectorType ?? "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._blobStorageComponent = ComponentFactory.get(options.blobStorageComponentType ?? "blob-storage");
+        this._blobStorageConnector = BlobStorageConnectorFactory.get(options.blobStorageConnectorType ?? "blob-storage");
         this._identityConnector = IdentityConnectorFactory.get(options.identityConnectorType ?? "identity");
+        this._taskSchedulerComponent = ComponentFactory.get(options.taskSchedulerComponentType ?? "task-scheduler");
         this._config = {
-            synchronisedStorageKey: options.config.synchronisedStorageKey,
             synchronisedStorageMethodId: options.config.synchronisedStorageMethodId ?? "synchronised-storage-assertion",
-            entityUpdateIntervalMs: options.config.entityUpdateIntervalMs ??
-                SynchronisedStorageService._DEFAULT_ENTITY_UPDATE_INTERVAL_MS,
+            entityUpdateIntervalMinutes: options.config.entityUpdateIntervalMinutes ??
+                SynchronisedStorageService._DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES,
             isTrustedNode: options.config.isTrustedNode ?? false,
-            consolidationIntervalMs: options.config.consolidationIntervalMs ??
-                SynchronisedStorageService._DEFAULT_CONSOLIDATION_INTERVAL_MS,
+            consolidationIntervalMinutes: options.config.consolidationIntervalMinutes ??
+                SynchronisedStorageService._DEFAULT_CONSOLIDATION_INTERVAL_MINUTES,
             consolidationBatchSize: options.config.consolidationBatchSize ??
-                SynchronisedStorageService._DEFAULT_CONSOLIDATION_BATCH_SIZE
+                SynchronisedStorageService._DEFAULT_CONSOLIDATION_BATCH_SIZE,
+            blobStorageEncryptionKeyId: options.config.blobStorageEncryptionKeyId ?? "synchronised-storage-blob-encryption-key",
+            verifiableStorageKeyId: options.config.verifiableStorageKeyId
         };
+        this._synchronisedStorageKey =
+            verifiableStorageKeys[options.config.verifiableStorageKeyId] ?? options.config.verifiableStorageKeyId;
         // If this is not a trusted node, we need to use a synchronised storage service
         // to synchronise with a trusted node.
         if (!this._config.isTrustedNode) {
@@ -1123,13 +1634,14 @@ class SynchronisedStorageService {
             this._trustedSynchronisedStorageComponent =
                 ComponentFactory.get(options.trustedSynchronisedStorageComponentType);
         }
-        this._changeSetHelper = new ChangeSetHelper(this._logging, this._eventBusComponent, this._blobStorageComponent, this._identityConnector, this._config.synchronisedStorageMethodId);
+        this._blobStorageHelper = new BlobStorageHelper(this._logging, this._vaultConnector, this._blobStorageConnector, this._config.blobStorageEncryptionKeyId, this._config.isTrustedNode);
+        this._changeSetHelper = new ChangeSetHelper(this._logging, this._eventBusComponent, this._identityConnector, this._blobStorageHelper, this._config.synchronisedStorageMethodId);
         this._localSyncStateHelper = new LocalSyncStateHelper(this._logging, this._localSyncSnapshotEntryEntityStorage, this._changeSetHelper);
-        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._logging, this._eventBusComponent, this._blobStorageComponent, this._verifiableSyncPointerStorageConnector, this._changeSetHelper, this._config.synchronisedStorageKey);
-        this._consolidationTimers = {};
-        this._entityUpdateTimers = {};
-        this._eventBusComponent.subscribe(SynchronisedStorageTopics.RegisterSchemaType, async (event) => this.registerType(event.data));
-        this._eventBusComponent.subscribe(SynchronisedStorageTopics.LocalItemChange, async (event) => this._localSyncStateHelper.addLocalChange(event.data.schemaType, event.data.operation, event.data.id));
+        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._logging, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, this._config.isTrustedNode);
+        this._serviceStarted = false;
+        this._activeStorageKeys = {};
+        this._eventBusComponent.subscribe(SynchronisedStorageTopics.RegisterStorageKey, async (event) => this.registerStorageKey(event.data));
+        this._eventBusComponent.subscribe(SynchronisedStorageTopics.LocalItemChange, async (event) => this._localSyncStateHelper.addLocalChange(event.data.storageKey, event.data.operation, event.data.id));
     }
     /**
      * The component needs to be started when the node is initialized.
@@ -1141,6 +1653,20 @@ class SynchronisedStorageService {
     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 (!this._config.isTrustedNode && !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.
@@ -1150,48 +1676,88 @@ class SynchronisedStorageService {
      * @returns Nothing.
      */
     async stop(nodeIdentity, nodeLoggingConnectorType, componentState) {
-        for (const schemaType in this._entityUpdateTimers) {
-            clearTimeout(this._entityUpdateTimers[schemaType]);
-            delete this._entityUpdateTimers[schemaType];
+        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 (!this._config.isTrustedNode) {
+            throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
-        for (const schemaType in this._consolidationTimers) {
-            clearTimeout(this._consolidationTimers[schemaType]);
-            delete this._consolidationTimers[schemaType];
+        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 complete set of changes, assumes this is a trusted node.
-     * @param changeSetStorageId The id of the change set to synchronise in blob storage.
+     * 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(changeSetStorageId) {
+    async syncChangeSet(syncChangeSet) {
         if (!this._config.isTrustedNode) {
             throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
-        // This method is called by non trusted nodes to synchronise changes
-        Guards.stringValue(this.CLASS_NAME, "changeSetStorageId", changeSetStorageId);
+        Guards.object(this.CLASS_NAME, "syncChangeSet", syncChangeSet);
+        await this._logging?.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 changeSet = await this._changeSetHelper.getAndApplyChangeset(changeSetStorageId);
-        if (!Is.empty(changeSet)) {
-            await this._remoteSyncStateHelper.addChangeSetToSyncState(changeSetStorageId);
+        const copy = await this._changeSetHelper.copyChangeset(syncChangeSet);
+        if (!Is.empty(copy) && Is.stringValue(this._nodeIdentity)) {
+            // 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 schemaType The schema type to sync.
+     * @param storageKey The storage key to sync.
      * @returns Nothing.
      * @internal
      */
-    async startEntitySync(schemaType) {
+    async startEntitySync(storageKey) {
         try {
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                message: "startEntitySync",
+                data: {
+                    storageKey
+                }
+            });
             // First we check for remote changes
-            await this.updateFromRemoteSyncState(schemaType);
+            await this.updateFromRemoteSyncState(storageKey);
             // Now send any updates we have to the remote storage
-            await this.updateFromLocalSyncState(schemaType);
+            await this.updateFromLocalSyncState(storageKey);
         }
         catch (error) {
             await this._logging?.log({
@@ -1201,27 +1767,31 @@ class SynchronisedStorageService {
                 error: BaseError.fromError(error)
             });
         }
-        finally {
-            // Set a timer to check for updates again
-            this._entityUpdateTimers[schemaType] = setTimeout(async () => this.startEntitySync(schemaType), this._config.entityUpdateIntervalMs);
-        }
     }
     /**
      * Check for updates in the remote storage.
-     * @param schemaType The schema type to check for updates.
+     * @param storageKey The storage key to check for updates.
      * @returns Nothing.
      * @internal
      */
-    async updateFromRemoteSyncState(schemaType) {
-        // Get the verifiable sync pointer from the verifiable storage
-        const verifiableSyncPointer = await this._remoteSyncStateHelper.getVerifiableSyncPointer();
-        if (!Is.empty(verifiableSyncPointer)) {
+    async updateFromRemoteSyncState(storageKey) {
+        await this._logging?.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.getRemoteSyncState(verifiableSyncPointer.syncPointerId);
+            const remoteSyncState = await this._remoteSyncStateHelper.getRemoteSyncState(verifiableSyncPointerStore.syncPointers[storageKey]);
             // If we got the sync state we can try and sync from it
             if (!Is.undefined(remoteSyncState)) {
-                await this._localSyncStateHelper.syncFromRemote(schemaType, remoteSyncState);
+                await this._localSyncStateHelper.applySyncState(storageKey, remoteSyncState);
             }
         }
     }
@@ -1230,47 +1800,94 @@ class SynchronisedStorageService {
      * @returns Nothing.
      * @internal
      */
-    async updateFromLocalSyncState(schemaType) {
-        if (Is.stringValue(this._nodeIdentity)) {
-            // Ge the current local change snapshot
-            const localChangeSnapshot = await this._localSyncStateHelper.getLocalChangeSnapshot(schemaType);
-            if (!Is.empty(localChangeSnapshot)) {
-                await this._remoteSyncStateHelper.createAndStoreChangeSet(schemaType, localChangeSnapshot.localChanges, async (changeSetStorageId) => {
-                    if (Is.stringValue(changeSetStorageId)) {
-                        // Send the local changes to the remote storage if we are a trusted node
-                        if (this._config.isTrustedNode) {
-                            await this._remoteSyncStateHelper.addChangeSetToSyncState(changeSetStorageId);
+    async updateFromLocalSyncState(storageKey) {
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "updateFromLocalSyncState",
+            data: {
+                storageKey
+            }
+        });
+        const localChangeSnapshot = await this._localSyncStateHelper.getLocalChangeSnapshot(storageKey);
+        if (Is.arrayValue(localChangeSnapshot.changes)) {
+            await this._remoteSyncStateHelper.buildChangeSet(storageKey, localChangeSnapshot.changes, async (syncChangeSet, changeSetStorageId) => {
+                if (Is.empty(syncChangeSet) && Is.empty(changeSetStorageId)) {
+                    await this._logging?.log({
+                        level: "info",
+                        source: this.CLASS_NAME,
+                        message: "builtStorageChangeSetNone",
+                        data: {
+                            storageKey
                         }
-                        else if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
-                            // If we are not a trusted node, we need to send the changes to the trusted node
-                            await this._trustedSynchronisedStorageComponent.syncChangeSet(changeSetStorageId);
+                    });
+                }
+                else {
+                    await this._logging?.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 (this._config.isTrustedNode && 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._logging?.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._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                message: "updateFromLocalSyncStateNoChanges",
+                data: {
+                    storageKey
+                }
+            });
         }
     }
     /**
      * Start the consolidation sync.
-     * @param schemaType The schema type to consolidate.
+     * @param storageKey The storage key to consolidate.
      * @returns Nothing.
      * @internal
      */
-    async startConsolidationSync(schemaType) {
+    async startConsolidationSync(storageKey) {
         let localChangeSnapshot;
         try {
-            // If we are performing a consolidation, we can remove the local changes
-            await this._localSyncStateHelper.getLocalChangeSnapshot(schemaType);
+            // If we are performing a consolidation, we can remove the local change snapshot
+            // as we are going to create a complete changeset from the DB
+            localChangeSnapshot = await this._localSyncStateHelper.getLocalChangeSnapshot(storageKey);
             if (!Is.empty(localChangeSnapshot)) {
                 await this._localSyncStateHelper.removeLocalChangeSnapshot(localChangeSnapshot);
             }
-            if (Is.stringValue(this._nodeIdentity)) {
-                await this._remoteSyncStateHelper.consolidateFromLocal(schemaType, this._config.consolidationBatchSize ??
-                    SynchronisedStorageService._DEFAULT_CONSOLIDATION_BATCH_SIZE);
-                // The consolidation was successful, so we can remove the local change snapshot permanently
-                localChangeSnapshot = undefined;
-            }
+            await this._remoteSyncStateHelper.consolidationStart(storageKey, this._config.consolidationBatchSize ??
+                SynchronisedStorageService._DEFAULT_CONSOLIDATION_BATCH_SIZE);
+            // The consolidation was successful, so we can remove the local change snapshot permanently
+            localChangeSnapshot = undefined;
         }
         catch (error) {
             if (localChangeSnapshot) {
@@ -1284,32 +1901,62 @@ class SynchronisedStorageService {
                 error: BaseError.fromError(error)
             });
         }
-        finally {
-            // Set a timer to perform the consolidation again
-            this._consolidationTimers[schemaType] = setTimeout(async () => this.startConsolidationSync(schemaType), this._config.consolidationIntervalMs);
-        }
     }
     /**
      * Register a new sync type.
-     * @param syncRegisterType The sync register type to register.
+     * @param syncRegisterStorageKey The sync register type to register.
      * @internal
      */
-    async registerType(syncRegisterType) {
+    async registerStorageKey(syncRegisterStorageKey) {
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
-            message: "registerType",
+            message: "registerStorageKey",
             data: {
-                schemaType: syncRegisterType.schemaType
+                storageKey: syncRegisterStorageKey.storageKey
             }
         });
-        if (this._config.entityUpdateIntervalMs > 0) {
-            await this.startEntitySync(syncRegisterType.schemaType);
+        if (Is.empty(this._activeStorageKeys[syncRegisterStorageKey.storageKey])) {
+            this._activeStorageKeys[syncRegisterStorageKey.storageKey] = false;
+            if (this._serviceStarted) {
+                await this.activateStorageKey(syncRegisterStorageKey.storageKey);
+            }
         }
-        if (this._config.isTrustedNode && this._config.consolidationIntervalMs > 0) {
-            await this.startConsolidationSync(syncRegisterType.schemaType);
+    }
+    /**
+     * 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._logging?.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 (this._config.isTrustedNode && 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, synchronisedStorageSyncChangeSetRequest, tagsSynchronisedStorage };
+export { SyncSnapshotEntry, SynchronisedStorageService, generateRestRoutesSynchronisedStorage, initSchema, restEntryPoints, synchronisedStorageGetDecryptionKeyRequest, synchronisedStorageSyncChangeSetRequest, tagsSynchronisedStorage };