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

package/dist/cjs/index.cjs

@@ -3,13 +3,15 @@
 var entity = require('@twin.org/entity');
 var core = require('@twin.org/core');
 var web = require('@twin.org/web');
+var blobStorageModels = require('@twin.org/blob-storage-models');
 var entityStorageModels = require('@twin.org/entity-storage-models');
 var identityModels = require('@twin.org/identity-models');
 var loggingModels = require('@twin.org/logging-models');
+var standardsW3cDid = require('@twin.org/standards-w3c-did');
 var synchronisedStorageModels = require('@twin.org/synchronised-storage-models');
+var vaultModels = require('@twin.org/vault-models');
 var verifiableStorageModels = require('@twin.org/verifiable-storage-models');
-var blobStorageModels = require('@twin.org/blob-storage-models');
-var standardsW3cDid = require('@twin.org/standards-w3c-did');
+var crypto = require('@twin.org/crypto');
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -102,8 +104,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",
@@ -111,8 +113,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"
                         }
                     }
                 }
@@ -122,9 +145,61 @@ function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
             {
                 type: "INoContentResponse"
             }
-        ]
+        ],
+        // Authentication is provided by the proof in the request body.
+        skipAuth: true
+    };
+    const getDecryptionKeyRoute = {
+        operationId: "synchronisedStorageGetDecryptionKeyRequest",
+        summary: "Request the decryption key.",
+        tag: tagsSynchronisedStorage[0].name,
+        method: "POST",
+        path: `${baseRouteName}/decryption-key`,
+        handler: async (httpRequestContext, request) => synchronisedStorageGetDecryptionKeyRequest(httpRequestContext, componentName, request),
+        requestType: {
+            type: "ISyncChangeSetRequest",
+            examples: [
+                {
+                    id: "synchronisedStorageSyncGetDecryptionKeyRequestExample",
+                    request: {
+                        body: {
+                            nodeIdentity: "did:entity-storage:0xd2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2",
+                            proof: {
+                                "@context": "https://www.w3.org/ns/credentials/v2",
+                                created: "2025-05-29T01:00:00.000Z",
+                                cryptosuite: "eddsa-jcs-2022",
+                                proofPurpose: "assertionMethod",
+                                proofValue: "z5efBErQs3YBLZoH7jgKMQaRc9YjAxA5XSYKmW3FmTBDw9WionT2NS2x1SMvcRyBvw53cSSoaCT1xQH9tkWngGCX3",
+                                type: "DataIntegrityProof",
+                                verificationMethod: "did:entity-storage:0xd0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0#synchronised-storage-assertion"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ISyncDecryptionKeyResponse",
+                examples: [
+                    {
+                        id: "synchronisedStorageSyncGetDecryptionKeyResponseExample",
+                        response: {
+                            body: {
+                                decryptionKey: "z5efBErQs3YBLZoH7jgKMQaRc9YjAxA5XSYKmW3FmTBDw9WionT2NS2x1SMvcRyBvw53cSSoaCT1xQH9tkWngGCX3"
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IUnauthorizedResponse"
+            }
+        ],
+        // Authentication is provided by the proof in the request body.
+        skipAuth: true
     };
-    return [syncChangeSetRoute];
+    return [syncChangeSetRoute, getDecryptionKeyRoute];
 }
 /**
  * Perform the sync change set operation.
@@ -135,13 +210,31 @@ function generateRestRoutesSynchronisedStorage(baseRouteName, componentName) {
  */
 async function synchronisedStorageSyncChangeSetRequest(httpRequestContext, componentName, request) {
     core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
     const component = core.ComponentFactory.get(componentName);
-    await component.syncChangeSet(request.query.changeSetStorageId);
+    await component.syncChangeSet(request.body);
     return {
         statusCode: web.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) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    const key = await component.getDecryptionKey(request.body.nodeIdentity, request.body.proof);
+    return {
+        body: {
+            decryptionKey: key
+        }
+    };
+}
 
 const restEntryPoints = [
     {
@@ -161,6 +254,163 @@ function initSchema() {
     entity.EntitySchemaFactory.register("SyncSnapshotEntry", () => entity.EntitySchemaHelper.getSchema(exports.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 (core.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, vaultModels.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 crypto.RSA(core.Converter.base64ToBytes(key));
+                    compressedBlob = rsa.decrypt(encryptedBlob);
+                }
+                const decompressedBlob = await core.Compression.decompress(compressedBlob, core.CompressionType.Gzip);
+                await this._logging?.log({
+                    level: "info",
+                    source: this.CLASS_NAME,
+                    message: "loadedBlob",
+                    data: {
+                        blobId
+                    }
+                });
+                return core.ObjectHelper.fromBytes(decompressedBlob);
+            }
+        }
+        catch (error) {
+            await this._logging?.log({
+                level: "error",
+                source: this.CLASS_NAME,
+                message: "loadBlobFailed",
+                data: {
+                    blobId
+                },
+                error: core.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 core.GeneralError(this.CLASS_NAME, "notTrustedNode");
+        }
+        const compressedBlob = await core.Compression.compress(core.ObjectHelper.toBytes(blob), core.CompressionType.Gzip);
+        const encryptedBlob = await this._vaultConnector.encrypt(this._blobStorageEncryptionKeyId, vaultModels.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: core.BaseError.fromError(error)
+            });
+            throw error;
+        }
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -182,10 +432,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
@@ -196,37 +446,73 @@ 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 (core.Is.stringBase64(blobEntry.blob)) {
-            const syncChangeset = core.ObjectHelper.fromBytes(core.Converter.base64ToBytes(blobEntry.blob));
-            const verified = await this.verifyChangesetProof(syncChangeset);
-            return verified ? syncChangeset : undefined;
+        try {
+            const syncChangeSet = await this._blobStorageHelper.load(changeSetStorageId);
+            if (core.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: core.BaseError.fromError(error)
+            });
+        }
+        await this._logging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            message: "getChangeSetEmpty",
+            data: {
+                changeSetStorageId
+            }
+        });
     }
     /**
      * Apply a sync changeset.
@@ -260,13 +546,18 @@ class ChangeSetHelper {
                 switch (change.operation) {
                     case synchronisedStorageModels.SyncChangeOperation.Set:
                         if (!core.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(synchronisedStorageModels.SynchronisedStorageTopics.RemoteItemSet, {
                                 storageKey: syncChangeset.storageKey,
-                                entity: change.entity
+                                entity: {
+                                    ...change.entity,
+                                    id: change.id,
+                                    nodeIdentity: syncChangeset.nodeIdentity
+                                }
                             });
                         }
                         break;
@@ -285,10 +576,9 @@ class ChangeSetHelper {
     /**
      * Store the changeset.
      * @param syncChangeSet The sync change set to store.
-     * @param nodeIdentity The node identity to use for the changeset.
      * @returns The id of the change set.
      */
-    async storeChangeSet(syncChangeSet, nodeIdentity) {
+    async storeChangeSet(syncChangeSet) {
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
@@ -297,12 +587,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(core.Converter.bytesToBase64(core.ObjectHelper.toBytes(syncChangeSet)), undefined, undefined, undefined, {
-            disableEncryption: true,
-            compress: blobStorageModels.BlobStorageCompressionType.Gzip
-        }, undefined, nodeIdentity);
+        return this._blobStorageHelper.saveBlob(syncChangeSet);
     }
     /**
      * Verify the proof of a sync changeset.
@@ -321,6 +606,32 @@ class ChangeSetHelper {
             });
             return false;
         }
+        // If the proof or verification method is missing, the proof is invalid
+        const verificationMethod = syncChangeset.proof?.verificationMethod;
+        if (!core.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 = identityModels.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 = core.ObjectHelper.clone(syncChangeset);
         delete changeSetWithoutProof.proof;
         const isValid = await this._identityConnector.verifyProof(changeSetWithoutProof, syncChangeset.proof);
@@ -352,9 +663,10 @@ class ChangeSetHelper {
      * @returns The proof.
      */
     async createChangeSetProof(syncChangeset) {
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", this._nodeIdentity);
         const changeSetWithoutProof = core.ObjectHelper.clone(syncChangeset);
         delete changeSetWithoutProof.proof;
-        const proof = await this._identityConnector.createProof(syncChangeset.nodeIdentity, identityModels.DocumentHelper.joinId(syncChangeset.nodeIdentity, this._decentralisedStorageMethodId), standardsW3cDid.ProofTypes.DataIntegrityProof, changeSetWithoutProof);
+        const proof = await this._identityConnector.createProof(this._nodeIdentity, identityModels.DocumentHelper.joinId(this._nodeIdentity, this._decentralisedStorageMethodId), standardsW3cDid.ProofTypes.DataIntegrityProof, changeSetWithoutProof);
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
@@ -366,6 +678,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 (core.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 = core.ObjectHelper.clone(syncChangeSet);
+                copy.id = core.Converter.bytesToHex(core.RandomHelper.generate(32));
+                copy.proof = await this.createChangeSetProof(copy);
+                // Store the copy
+                return {
+                    syncChangeSet: copy,
+                    changeSetStorageId: await this.storeChangeSet(copy)
+                };
+            }
+        }
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -387,7 +728,7 @@ class LocalSyncStateHelper {
      * The storage connector for the sync snapshot entries.
      * @internal
      */
-    _localSyncSnapshotEntryEntityStorage;
+    _snapshotEntryEntityStorage;
     /**
      * The change set helper to use for applying changesets.
      * @internal
@@ -396,12 +737,12 @@ 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;
     }
     /**
@@ -438,7 +779,7 @@ class LocalSyncStateHelper {
         await this.setLocalChangeSnapshot(localChangeSnapshot);
     }
     /**
-     * Get the current local snapshot.
+     * 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.
      */
@@ -451,7 +792,7 @@ class LocalSyncStateHelper {
                 storageKey
             }
         });
-        const queryResult = await this._localSyncSnapshotEntryEntityStorage.query({
+        const queryResult = await this._snapshotEntryEntityStorage.query({
             conditions: [
                 {
                     property: "isLocalSnapshot",
@@ -493,7 +834,7 @@ class LocalSyncStateHelper {
         };
     }
     /**
-     * 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.
      */
@@ -506,10 +847,10 @@ class LocalSyncStateHelper {
                 storageKey: localChangeSnapshot.storageKey
             }
         });
-        await this._localSyncSnapshotEntryEntityStorage.set(localChangeSnapshot);
+        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.
      */
@@ -522,47 +863,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.
+     * Apply a sync state to the local node.
      * @param storageKey The storage key of the snapshot to sync with.
-     * @param remoteSyncState The sync state to sync with.
+     * @param syncState The sync state to sync with.
      * @returns Nothing.
      */
-    async syncFromRemote(storageKey, 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,
+                ...snapshot,
                 storageKey
             };
             if (core.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,
@@ -584,13 +925,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 ??
@@ -609,20 +951,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()
@@ -634,11 +977,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.
 /**
@@ -660,10 +1009,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
@@ -694,22 +1043,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(synchronisedStorageModels.SynchronisedStorageTopics.BatchResponse, async (response) => {
@@ -727,17 +1081,24 @@ class RemoteSyncStateHelper {
         this._nodeIdentity = nodeIdentity;
     }
     /**
-     * Create and store a 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(storageKey, changes, completeCallback) {
+    async buildChangeSet(storageKey, changes, completeCallback) {
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
-            message: "createAndStoreChangeSet",
+            message: "buildingChangeSet",
             data: {
                 storageKey,
                 changeCount: changes.length
@@ -796,12 +1157,14 @@ class RemoteSyncStateHelper {
             for (const change of changes) {
                 change.entity = this._populateFullChanges[storageKey].entities[change.id] ?? change.entity;
                 if (change.operation === synchronisedStorageModels.SyncChangeOperation.Set && core.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
+                    core.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
                     core.ObjectHelper.propertyDelete(change.entity, "nodeIdentity");
                 }
             }
-            // Add the changeset to the current snapshot
             const syncChangeSet = {
                 id: core.Converter.bytesToHex(core.RandomHelper.generate(32)),
                 dateCreated: new Date(Date.now()).toISOString(),
@@ -812,9 +1175,12 @@ class RemoteSyncStateHelper {
             try {
                 // 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, this._nodeIdentity);
-                await completeCallback(changeSetStorageId);
+                // 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({
@@ -857,23 +1223,26 @@ class RemoteSyncStateHelper {
         }
         // No current sync state, so we create a new one
         if (core.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 (core.Is.empty(currentSnapshot)) {
             currentSnapshot = {
+                version: SYNC_SNAPSHOT_VERSION,
                 id: core.Converter.bytesToHex(core.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);
@@ -888,12 +1257,13 @@ class RemoteSyncStateHelper {
      * @param batchSize The batch size to use for consolidation.
      * @returns Nothing.
      */
-    async consolidateFromLocal(storageKey, batchSize) {
+    async consolidationStart(storageKey, batchSize) {
         await this._logging?.log({
             level: "info",
             source: this.CLASS_NAME,
             message: "consolidationStarting"
         });
+        // Perform a batch request to start the consolidation
         await this._eventBusComponent.publish(synchronisedStorageModels.SynchronisedStorageTopics.BatchRequest, { storageKey, batchSize });
     }
     /**
@@ -901,44 +1271,47 @@ class RemoteSyncStateHelper {
      * @returns The sync pointer store.
      */
     async getVerifiableSyncPointerStore() {
-        try {
-            await this._logging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                message: "verifiableSyncPointerStoreRetrieving",
-                data: {
-                    key: this._synchronisedStorageKey
-                }
-            });
-            const syncPointerStore = await this._verifiableSyncPointerStorageConnector.get(this._synchronisedStorageKey, { includeData: true });
-            if (core.Is.uint8Array(syncPointerStore.data)) {
-                const syncPointer = core.ObjectHelper.fromBytes(syncPointerStore.data);
+        if (core.Is.stringValue(this._synchronisedStorageKey)) {
+            try {
                 await this._logging?.log({
                     level: "info",
                     source: this.CLASS_NAME,
-                    message: "verifiableSyncPointerStoreRetrieved",
+                    message: "verifiableSyncPointerStoreRetrieving",
                     data: {
                         key: this._synchronisedStorageKey
                     }
                 });
-                return syncPointer;
+                const syncPointerStore = await this._verifiableSyncPointerStorageConnector.get(this._synchronisedStorageKey, { includeData: true });
+                if (core.Is.uint8Array(syncPointerStore.data)) {
+                    const syncPointer = core.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 (!core.BaseError.someErrorName(err, core.NotFoundError.CLASS_NAME)) {
-                throw err;
+            catch (err) {
+                if (!core.BaseError.someErrorName(err, core.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: "verifiableSyncPointerStoreNotFound",
-            data: {
-                key: this._synchronisedStorageKey
-            }
-        });
         // If no sync pointer store exists, we return an empty one
         return {
+            version: SYNC_POINTER_STORE_VERSION,
             syncPointers: {}
         };
     }
@@ -948,7 +1321,7 @@ class RemoteSyncStateHelper {
      * @returns Nothing.
      */
     async storeVerifiableSyncPointerStore(syncPointerStore) {
-        if (this._nodeIdentity) {
+        if (core.Is.stringValue(this._nodeIdentity) && core.Is.stringValue(this._synchronisedStorageKey)) {
             await this._logging?.log({
                 level: "info",
                 source: this.CLASS_NAME,
@@ -975,9 +1348,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(core.Converter.bytesToBase64(core.ObjectHelper.toBytes(syncState)), undefined, undefined, undefined, { disableEncryption: true, compress: blobStorageModels.BlobStorageCompressionType.Gzip }, undefined, this._nodeIdentity);
+        return this._blobStorageHelper.saveBlob(syncState);
     }
     /**
      * Get the remote sync state.
@@ -994,11 +1365,8 @@ class RemoteSyncStateHelper {
                     syncPointerId
                 }
             });
-            const blobEntry = await this._blobStorageComponent.get(syncPointerId, {
-                includeContent: true
-            }, undefined, this._nodeIdentity);
-            if (core.Is.stringBase64(blobEntry.blob)) {
-                const syncState = core.ObjectHelper.fromBytes(core.Converter.base64ToBytes(blobEntry.blob));
+            const syncState = await this._blobStorageHelper.load(syncPointerId);
+            if (core.Is.object(syncState)) {
                 await this._logging?.log({
                     level: "info",
                     source: this.CLASS_NAME,
@@ -1011,10 +1379,16 @@ class RemoteSyncStateHelper {
                 return syncState;
             }
         }
-        catch (err) {
-            if (!core.BaseError.someErrorName(err, core.NotFoundError.CLASS_NAME)) {
-                throw err;
-            }
+        catch (error) {
+            await this._logging?.log({
+                level: "warn",
+                source: this.CLASS_NAME,
+                message: "getSyncStateError",
+                data: {
+                    syncPointerId
+                },
+                error: core.BaseError.fromError(error)
+            });
         }
         await this._logging?.log({
             level: "info",
@@ -1026,18 +1400,20 @@ 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 (core.Is.stringValue(this._nodeIdentity)) {
+            const now = new Date(Date.now()).toISOString();
             // Create a new snapshot entry for the current batch
             const syncChangeSet = {
                 id: core.Converter.bytesToHex(core.RandomHelper.generate(32)),
-                dateCreated: new Date(Date.now()).toISOString(),
+                dateCreated: now,
+                dateModified: now,
                 changes: response.entities.map(change => ({
                     operation: synchronisedStorageModels.SyncChangeOperation.Set,
-                    id: change[response.primaryKey]
+                    id: change.id
                 })),
                 storageKey: response.storageKey,
                 nodeIdentity: this._nodeIdentity
@@ -1045,25 +1421,37 @@ class RemoteSyncStateHelper {
             // 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, this._nodeIdentity);
+            const changeSetStorageId = await this._changeSetHelper.storeChangeSet(syncChangeSet);
             // Add the changeset storage id to the snapshot ids
             this._batchResponseStorageIds[response.storageKey] ??= [];
             this._batchResponseStorageIds[response.storageKey].push(changeSetStorageId);
+            // If this is the last entry in the batch response, we can create the consolidated snapshot
             if (response.lastEntry) {
-                const syncState = { snapshots: [] };
+                // Get the current sync pointer store
+                const syncPointerStore = await this.getVerifiableSyncPointerStore();
+                let syncState;
+                if (core.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: core.Converter.bytesToHex(core.RandomHelper.generate(32)),
-                    dateCreated: new Date(Date.now()).toISOString(),
+                    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);
-                // Get the current sync pointer store
-                const syncPointerStore = await this.getVerifiableSyncPointerStore();
                 syncPointerStore.syncPointers[response.storageKey] = syncStateId;
                 // Store the verifiable sync pointer in the verifiable storage
                 await this.storeVerifiableSyncPointerStore(syncPointerStore);
+                // Remove the batch response storage ids for the storage key
+                // as we have consolidated the changes
+                delete this._batchResponseStorageIds[response.storageKey];
                 await this._logging?.log({
                     level: "info",
                     source: this.CLASS_NAME,
@@ -1132,16 +1520,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
@@ -1162,6 +1555,11 @@ class SynchronisedStorageService {
      * @internal
      */
     _trustedSynchronisedStorageComponent;
+    /**
+     * The blob storage helper.
+     * @internal
+     */
+    _blobStorageHelper;
     /**
      * The change set helper.
      * @internal
@@ -1182,6 +1580,11 @@ class SynchronisedStorageService {
      * @internal
      */
     _config;
+    /**
+     * The synchronised storage key to use for the remote synchronised storage.
+     * @internal
+     */
+    _synchronisedStorageKey;
     /**
      * The flag to determine if the service has been started.
      * @internal
@@ -1206,13 +1609,13 @@ class SynchronisedStorageService {
         core.Guards.object(this.CLASS_NAME, "options.config", options.config);
         this._eventBusComponent = core.ComponentFactory.get(options.eventBusComponentType ?? "event-bus");
         this._logging = loggingModels.LoggingConnectorFactory.getIfExists(options.loggingConnectorType ?? "logging");
+        this._vaultConnector = vaultModels.VaultConnectorFactory.get(options.vaultConnectorType ?? "vault");
         this._localSyncSnapshotEntryEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(options.syncSnapshotStorageConnectorType ?? "sync-snapshot-entry");
         this._verifiableSyncPointerStorageConnector = verifiableStorageModels.VerifiableStorageConnectorFactory.get(options.verifiableStorageConnectorType ?? "verifiable-storage");
-        this._blobStorageComponent = core.ComponentFactory.get(options.blobStorageComponentType ?? "blob-storage");
+        this._blobStorageConnector = blobStorageModels.BlobStorageConnectorFactory.get(options.blobStorageConnectorType ?? "blob-storage");
         this._identityConnector = identityModels.IdentityConnectorFactory.get(options.identityConnectorType ?? "identity");
         this._taskSchedulerComponent = core.ComponentFactory.get(options.taskSchedulerComponentType ?? "task-scheduler");
         this._config = {
-            synchronisedStorageKey: options.config.synchronisedStorageKey,
             synchronisedStorageMethodId: options.config.synchronisedStorageMethodId ?? "synchronised-storage-assertion",
             entityUpdateIntervalMinutes: options.config.entityUpdateIntervalMinutes ??
                 SynchronisedStorageService._DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES,
@@ -1220,8 +1623,12 @@ class SynchronisedStorageService {
             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) {
@@ -1229,12 +1636,13 @@ class SynchronisedStorageService {
             this._trustedSynchronisedStorageComponent =
                 core.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._remoteSyncStateHelper = new RemoteSyncStateHelper(this._logging, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, this._config.isTrustedNode);
         this._serviceStarted = false;
         this._activeStorageKeys = {};
-        this._eventBusComponent.subscribe(synchronisedStorageModels.SynchronisedStorageTopics.RegisterStorageKey, async (event) => this.registerType(event.data));
+        this._eventBusComponent.subscribe(synchronisedStorageModels.SynchronisedStorageTopics.RegisterStorageKey, async (event) => this.registerStorageKey(event.data));
         this._eventBusComponent.subscribe(synchronisedStorageModels.SynchronisedStorageTopics.LocalItemChange, async (event) => this._localSyncStateHelper.addLocalChange(event.data.storageKey, event.data.operation, event.data.id));
     }
     /**
@@ -1247,7 +1655,16 @@ 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 && !core.Is.empty(this._trustedSynchronisedStorageComponent)) {
+            const proof = await this._identityConnector.createProof(this._nodeIdentity, identityModels.DocumentHelper.joinId(this._nodeIdentity, this._config.synchronisedStorageMethodId), standardsW3cDid.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);
@@ -1268,24 +1685,59 @@ class SynchronisedStorageService {
         }
     }
     /**
-     * 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.
+     * 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 core.GeneralError(this.CLASS_NAME, "notTrustedNode");
+        }
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        core.Guards.object(this.CLASS_NAME, "proof", proof);
+        const isValid = await this._identityConnector.verifyProof({ nodeIdentity }, proof);
+        if (!isValid) {
+            throw new core.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 (core.Is.undefined(key.publicKey)) {
+            throw new core.UnauthorizedError(this.CLASS_NAME, "decryptionKeyNotFound");
+        }
+        return core.Converter.bytesToBase64(key.publicKey);
+    }
+    /**
+     * Synchronise a set of changes from an untrusted node, assumes this is a trusted node.
+     * @param syncChangeSet The change set to synchronise.
      * @returns Nothing.
      */
-    async syncChangeSet(changeSetStorageId) {
+    async syncChangeSet(syncChangeSet) {
         if (!this._config.isTrustedNode) {
             throw new core.GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
-        // This method is called by non trusted nodes to synchronise changes
-        core.Guards.stringValue(this.CLASS_NAME, "changeSetStorageId", changeSetStorageId);
+        core.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 (!core.Is.empty(changeSet)) {
-            await this._remoteSyncStateHelper.addChangeSetToSyncState(changeSet.storageKey, changeSetStorageId);
+        const copy = await this._changeSetHelper.copyChangeset(syncChangeSet);
+        if (!core.Is.empty(copy) && core.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);
         }
     }
     /**
@@ -1341,7 +1793,7 @@ class SynchronisedStorageService {
             const remoteSyncState = await this._remoteSyncStateHelper.getRemoteSyncState(verifiableSyncPointerStore.syncPointers[storageKey]);
             // If we got the sync state we can try and sync from it
             if (!core.Is.undefined(remoteSyncState)) {
-                await this._localSyncStateHelper.syncFromRemote(storageKey, remoteSyncState);
+                await this._localSyncStateHelper.applySyncState(storageKey, remoteSyncState);
             }
         }
     }
@@ -1361,38 +1813,51 @@ class SynchronisedStorageService {
         });
         const localChangeSnapshot = await this._localSyncStateHelper.getLocalChangeSnapshot(storageKey);
         if (core.Is.arrayValue(localChangeSnapshot.changes)) {
-            await this._remoteSyncStateHelper.createAndStoreChangeSet(storageKey, localChangeSnapshot.changes, async (changeSetStorageId) => {
-                if (core.Is.stringValue(changeSetStorageId)) {
+            await this._remoteSyncStateHelper.buildChangeSet(storageKey, localChangeSnapshot.changes, async (syncChangeSet, changeSetStorageId) => {
+                if (core.Is.empty(syncChangeSet) && core.Is.empty(changeSetStorageId)) {
                     await this._logging?.log({
                         level: "info",
                         source: this.CLASS_NAME,
-                        message: "createdStorageChangeSet",
+                        message: "builtStorageChangeSetNone",
+                        data: {
+                            storageKey
+                        }
+                    });
+                }
+                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) {
+                    if (this._config.isTrustedNode && core.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 (!core.Is.empty(this._trustedSynchronisedStorageComponent)) {
+                    else if (!core.Is.empty(this._trustedSynchronisedStorageComponent) &&
+                        core.Is.object(syncChangeSet)) {
                         // If we are not a trusted node, we need to send the changes to the trusted node
-                        await this._trustedSynchronisedStorageComponent.syncChangeSet(changeSetStorageId);
+                        // 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: "createdStorageChangeSetNone",
-                        data: {
-                            storageKey
-                        }
-                    });
-                }
             });
         }
         else {
@@ -1415,17 +1880,16 @@ class SynchronisedStorageService {
     async startConsolidationSync(storageKey) {
         let localChangeSnapshot;
         try {
-            // If we are performing a consolidation, we can remove the local changes
-            await this._localSyncStateHelper.getLocalChangeSnapshot(storageKey);
+            // 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 (!core.Is.empty(localChangeSnapshot)) {
                 await this._localSyncStateHelper.removeLocalChangeSnapshot(localChangeSnapshot);
             }
-            if (core.Is.stringValue(this._nodeIdentity)) {
-                await this._remoteSyncStateHelper.consolidateFromLocal(storageKey, 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) {
@@ -1442,22 +1906,22 @@ class SynchronisedStorageService {
     }
     /**
      * 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: {
-                storageKey: syncRegisterType.storageKey
+                storageKey: syncRegisterStorageKey.storageKey
             }
         });
-        if (core.Is.empty(this._activeStorageKeys[syncRegisterType.storageKey])) {
-            this._activeStorageKeys[syncRegisterType.storageKey] = false;
+        if (core.Is.empty(this._activeStorageKeys[syncRegisterStorageKey.storageKey])) {
+            this._activeStorageKeys[syncRegisterStorageKey.storageKey] = false;
             if (this._serviceStarted) {
-                await this.activateStorageKey(syncRegisterType.storageKey);
+                await this.activateStorageKey(syncRegisterStorageKey.storageKey);
             }
         }
     }
@@ -1471,7 +1935,7 @@ class SynchronisedStorageService {
             await this._logging?.log({
                 level: "info",
                 source: this.CLASS_NAME,
-                message: "activateType",
+                message: "activateStorageKey",
                 data: {
                     storageKey
                 }
@@ -1501,5 +1965,6 @@ exports.SynchronisedStorageService = SynchronisedStorageService;
 exports.generateRestRoutesSynchronisedStorage = generateRestRoutesSynchronisedStorage;
 exports.initSchema = initSchema;
 exports.restEntryPoints = restEntryPoints;
+exports.synchronisedStorageGetDecryptionKeyRequest = synchronisedStorageGetDecryptionKeyRequest;
 exports.synchronisedStorageSyncChangeSetRequest = synchronisedStorageSyncChangeSetRequest;
 exports.tagsSynchronisedStorage = tagsSynchronisedStorage;