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

package/dist/cjs/index.cjs

@@ -278,9 +278,9 @@ function initSchema() {
     entity.EntitySchemaFactory.register("SyncSnapshotEntry", () => entity.EntitySchemaHelper.getSchema(exports.SyncSnapshotEntry));
 }
 
-var mainnet = "";
-var testnet = "";
-var devnet = "";
+var mainnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
+var testnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
+var devnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
 var verifiableStorageKeys = {
 	mainnet: mainnet,
 	testnet: testnet,
@@ -1866,6 +1866,7 @@ class SynchronisedStorageService {
     constructor(options) {
         core.Guards.object(this.CLASS_NAME, "options", options);
         core.Guards.object(this.CLASS_NAME, "options.config", options.config);
+        core.Guards.stringValue(this.CLASS_NAME, "options.config.verifiableStorageKeyId", options.config.verifiableStorageKeyId);
         this._eventBusComponent = core.ComponentFactory.get(options.eventBusComponentType ?? "event-bus");
         this._loggingComponent = core.ComponentFactory.getIfExists(options.loggingComponentType ?? "logging");
         this._vaultConnector = vaultModels.VaultConnectorFactory.get(options.vaultConnectorType ?? "vault");
@@ -1874,11 +1875,18 @@ class SynchronisedStorageService {
         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");
+        // If this is empty we assume the local node has the rights to write to the verifiable storage.
+        let isTrustedNode = true;
+        if (!core.Is.empty(options.trustedSynchronisedStorageComponentType)) {
+            isTrustedNode = false;
+            // If it is set then we used the trusted component to send changesets to
+            this._trustedSynchronisedStorageComponent =
+                core.ComponentFactory.get(options.trustedSynchronisedStorageComponentType);
+        }
         this._config = {
             synchronisedStorageMethodId: options.config.synchronisedStorageMethodId ?? "synchronised-storage-assertion",
             entityUpdateIntervalMinutes: options.config.entityUpdateIntervalMinutes ??
                 SynchronisedStorageService._DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES,
-            isTrustedNode: options.config.isTrustedNode ?? false,
             consolidationIntervalMinutes: options.config.consolidationIntervalMinutes ??
                 SynchronisedStorageService._DEFAULT_CONSOLIDATION_INTERVAL_MINUTES,
             consolidationBatchSize: options.config.consolidationBatchSize ??
@@ -1889,17 +1897,11 @@ class SynchronisedStorageService {
         };
         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) {
-            core.Guards.stringValue(this.CLASS_NAME, "options.trustedSynchronisedStorageComponentType", options.trustedSynchronisedStorageComponentType);
-            this._trustedSynchronisedStorageComponent =
-                core.ComponentFactory.get(options.trustedSynchronisedStorageComponentType);
-        }
-        this._blobStorageHelper = new BlobStorageHelper(this._loggingComponent, this._vaultConnector, this._blobStorageConnector, this._config.blobStorageEncryptionKeyId, this._config.isTrustedNode);
+        core.Guards.stringValue(this.CLASS_NAME, "synchronisedStorageKey", this._synchronisedStorageKey);
+        this._blobStorageHelper = new BlobStorageHelper(this._loggingComponent, this._vaultConnector, this._blobStorageConnector, this._config.blobStorageEncryptionKeyId, isTrustedNode);
         this._changeSetHelper = new ChangeSetHelper(this._loggingComponent, this._eventBusComponent, this._identityConnector, this._blobStorageHelper, this._config.synchronisedStorageMethodId);
         this._localSyncStateHelper = new LocalSyncStateHelper(this._loggingComponent, this._localSyncSnapshotEntryEntityStorage, this._changeSetHelper);
-        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._loggingComponent, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, this._config.isTrustedNode, this._config.maxConsolidations);
+        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._loggingComponent, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, isTrustedNode, this._config.maxConsolidations);
         this._serviceStarted = false;
         this._activeStorageKeys = {};
         this._eventBusComponent.subscribe(synchronisedStorageModels.SynchronisedStorageTopics.RegisterStorageKey, async (event) => this.registerStorageKey(event.data));
@@ -1924,7 +1926,7 @@ class SynchronisedStorageService {
         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)) {
+        if (!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
@@ -1957,7 +1959,7 @@ class SynchronisedStorageService {
      * @returns The decryption key.
      */
     async getDecryptionKey(nodeIdentity, proof) {
-        if (!this._config.isTrustedNode) {
+        if (!core.Is.empty(this._trustedSynchronisedStorageComponent)) {
             throw new core.GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
@@ -1980,7 +1982,7 @@ class SynchronisedStorageService {
      * @returns Nothing.
      */
     async syncChangeSet(syncChangeSet) {
-        if (!this._config.isTrustedNode) {
+        if (!core.Is.empty(this._trustedSynchronisedStorageComponent)) {
             throw new core.GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
         core.Guards.object(this.CLASS_NAME, "syncChangeSet", syncChangeSet);
@@ -2102,7 +2104,8 @@ class SynchronisedStorageService {
                             }
                         });
                         // Send the local changes to the remote storage if we are a trusted node
-                        if (this._config.isTrustedNode && core.Is.stringValue(changeSetStorageId)) {
+                        if (core.Is.empty(this._trustedSynchronisedStorageComponent) &&
+                            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);
@@ -2210,7 +2213,8 @@ class SynchronisedStorageService {
                     }
                 ], async () => this.startEntitySync(storageKey));
             }
-            if (this._config.isTrustedNode && this._config.consolidationIntervalMinutes > 0) {
+            if (!core.Is.empty(this._trustedSynchronisedStorageComponent) &&
+                this._config.consolidationIntervalMinutes > 0) {
                 await this._taskSchedulerComponent.addTask(`synchronised-storage-consolidation-${storageKey}`, [
                     {
                         nextTriggerTime: Date.now(),

package/dist/esm/index.mjs

@@ -276,9 +276,9 @@ function initSchema() {
     EntitySchemaFactory.register("SyncSnapshotEntry", () => EntitySchemaHelper.getSchema(SyncSnapshotEntry));
 }
 
-var mainnet = "";
-var testnet = "";
-var devnet = "";
+var mainnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
+var testnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
+var devnet = "verifiable:iota:0x0000000000000000000000000000000000000000000000000000000000000000:0x0000000000000000000000000000000000000000000000000000000000000000";
 var verifiableStorageKeys = {
 	mainnet: mainnet,
 	testnet: testnet,
@@ -1864,6 +1864,7 @@ class SynchronisedStorageService {
     constructor(options) {
         Guards.object(this.CLASS_NAME, "options", options);
         Guards.object(this.CLASS_NAME, "options.config", options.config);
+        Guards.stringValue(this.CLASS_NAME, "options.config.verifiableStorageKeyId", options.config.verifiableStorageKeyId);
         this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType ?? "event-bus");
         this._loggingComponent = ComponentFactory.getIfExists(options.loggingComponentType ?? "logging");
         this._vaultConnector = VaultConnectorFactory.get(options.vaultConnectorType ?? "vault");
@@ -1872,11 +1873,18 @@ class SynchronisedStorageService {
         this._blobStorageConnector = BlobStorageConnectorFactory.get(options.blobStorageConnectorType ?? "blob-storage");
         this._identityConnector = IdentityConnectorFactory.get(options.identityConnectorType ?? "identity");
         this._taskSchedulerComponent = ComponentFactory.get(options.taskSchedulerComponentType ?? "task-scheduler");
+        // If this is empty we assume the local node has the rights to write to the verifiable storage.
+        let isTrustedNode = true;
+        if (!Is.empty(options.trustedSynchronisedStorageComponentType)) {
+            isTrustedNode = false;
+            // If it is set then we used the trusted component to send changesets to
+            this._trustedSynchronisedStorageComponent =
+                ComponentFactory.get(options.trustedSynchronisedStorageComponentType);
+        }
         this._config = {
             synchronisedStorageMethodId: options.config.synchronisedStorageMethodId ?? "synchronised-storage-assertion",
             entityUpdateIntervalMinutes: options.config.entityUpdateIntervalMinutes ??
                 SynchronisedStorageService._DEFAULT_ENTITY_UPDATE_INTERVAL_MINUTES,
-            isTrustedNode: options.config.isTrustedNode ?? false,
             consolidationIntervalMinutes: options.config.consolidationIntervalMinutes ??
                 SynchronisedStorageService._DEFAULT_CONSOLIDATION_INTERVAL_MINUTES,
             consolidationBatchSize: options.config.consolidationBatchSize ??
@@ -1887,17 +1895,11 @@ class SynchronisedStorageService {
         };
         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) {
-            Guards.stringValue(this.CLASS_NAME, "options.trustedSynchronisedStorageComponentType", options.trustedSynchronisedStorageComponentType);
-            this._trustedSynchronisedStorageComponent =
-                ComponentFactory.get(options.trustedSynchronisedStorageComponentType);
-        }
-        this._blobStorageHelper = new BlobStorageHelper(this._loggingComponent, this._vaultConnector, this._blobStorageConnector, this._config.blobStorageEncryptionKeyId, this._config.isTrustedNode);
+        Guards.stringValue(this.CLASS_NAME, "synchronisedStorageKey", this._synchronisedStorageKey);
+        this._blobStorageHelper = new BlobStorageHelper(this._loggingComponent, this._vaultConnector, this._blobStorageConnector, this._config.blobStorageEncryptionKeyId, isTrustedNode);
         this._changeSetHelper = new ChangeSetHelper(this._loggingComponent, this._eventBusComponent, this._identityConnector, this._blobStorageHelper, this._config.synchronisedStorageMethodId);
         this._localSyncStateHelper = new LocalSyncStateHelper(this._loggingComponent, this._localSyncSnapshotEntryEntityStorage, this._changeSetHelper);
-        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._loggingComponent, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, this._config.isTrustedNode, this._config.maxConsolidations);
+        this._remoteSyncStateHelper = new RemoteSyncStateHelper(this._loggingComponent, this._eventBusComponent, this._verifiableSyncPointerStorageConnector, this._blobStorageHelper, this._changeSetHelper, isTrustedNode, this._config.maxConsolidations);
         this._serviceStarted = false;
         this._activeStorageKeys = {};
         this._eventBusComponent.subscribe(SynchronisedStorageTopics.RegisterStorageKey, async (event) => this.registerStorageKey(event.data));
@@ -1922,7 +1924,7 @@ class SynchronisedStorageService {
         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)) {
+        if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
             const proof = await this._identityConnector.createProof(this._nodeIdentity, DocumentHelper.joinId(this._nodeIdentity, this._config.synchronisedStorageMethodId), ProofTypes.DataIntegrityProof, { nodeIdentity });
             const decryptionKey = await this._trustedSynchronisedStorageComponent.getDecryptionKey(this._nodeIdentity, proof);
             // We don't have the private key so instead we store the key as a secret in the vault
@@ -1955,7 +1957,7 @@ class SynchronisedStorageService {
      * @returns The decryption key.
      */
     async getDecryptionKey(nodeIdentity, proof) {
-        if (!this._config.isTrustedNode) {
+        if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
             throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
@@ -1978,7 +1980,7 @@ class SynchronisedStorageService {
      * @returns Nothing.
      */
     async syncChangeSet(syncChangeSet) {
-        if (!this._config.isTrustedNode) {
+        if (!Is.empty(this._trustedSynchronisedStorageComponent)) {
             throw new GeneralError(this.CLASS_NAME, "notTrustedNode");
         }
         Guards.object(this.CLASS_NAME, "syncChangeSet", syncChangeSet);
@@ -2100,7 +2102,8 @@ class SynchronisedStorageService {
                             }
                         });
                         // Send the local changes to the remote storage if we are a trusted node
-                        if (this._config.isTrustedNode && Is.stringValue(changeSetStorageId)) {
+                        if (Is.empty(this._trustedSynchronisedStorageComponent) &&
+                            Is.stringValue(changeSetStorageId)) {
                             // If we are a trusted node, we can add the change set to the sync state
                             // and remove the local change snapshot
                             await this._remoteSyncStateHelper.addChangeSetToSyncState(storageKey, changeSetStorageId);
@@ -2208,7 +2211,8 @@ class SynchronisedStorageService {
                     }
                 ], async () => this.startEntitySync(storageKey));
             }
-            if (this._config.isTrustedNode && this._config.consolidationIntervalMinutes > 0) {
+            if (!Is.empty(this._trustedSynchronisedStorageComponent) &&
+                this._config.consolidationIntervalMinutes > 0) {
                 await this._taskSchedulerComponent.addTask(`synchronised-storage-consolidation-${storageKey}`, [
                     {
                         nextTriggerTime: Date.now(),

package/dist/types/models/ISynchronisedStorageServiceConfig.d.ts

@@ -12,11 +12,6 @@ export interface ISynchronisedStorageServiceConfig {
      * @default 5
      */
     entityUpdateIntervalMinutes?: number;
-    /**
-     * Is this a node that has permission to write to the verifiable storage?
-     * @default false
-     */
-    isTrustedNode?: boolean;
     /**
      * Interval to perform consolidation of changesets, only used if isTrustedNode is set.
      * @default 60

package/dist/types/models/ISynchronisedStorageServiceConstructorOptions.d.ts

@@ -42,6 +42,7 @@ export interface ISynchronisedStorageServiceConstructorOptions {
     taskSchedulerComponentType?: string;
     /**
      * The synchronised entity storage component type to use if this node is not trusted.
+     * If this is set, this node uses it as the trusted node to store changesets.
      */
     trustedSynchronisedStorageComponentType?: string;
     /**

package/docs/changelog.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.0.1-next.9](https://github.com/twinfoundation/synchronised-storage/compare/synchronised-storage-service-v0.0.1-next.8...synchronised-storage-service-v0.0.1-next.9) (2025-08-13)
+
+
+### Features
+
+* add guards for verifiable storage keys ([5182e8b](https://github.com/twinfoundation/synchronised-storage/commit/5182e8b2a7868e8d396fd02964b0ed7f0c0a5947))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/synchronised-storage-models bumped from 0.0.1-next.8 to 0.0.1-next.9
+
+## [0.0.1-next.8](https://github.com/twinfoundation/synchronised-storage/compare/synchronised-storage-service-v0.0.1-next.7...synchronised-storage-service-v0.0.1-next.8) (2025-08-13)
+
+
+### Features
+
+* remove isTrustedNode from config and rely on trusted component ([cc2d987](https://github.com/twinfoundation/synchronised-storage/commit/cc2d98795044fc97b33fadf871188f6103f5c987))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/synchronised-storage-models bumped from 0.0.1-next.7 to 0.0.1-next.8
+
 ## [0.0.1-next.7](https://github.com/twinfoundation/synchronised-storage/compare/synchronised-storage-service-v0.0.1-next.6...synchronised-storage-service-v0.0.1-next.7) (2025-08-12)
 
 

package/docs/reference/interfaces/ISynchronisedStorageServiceConfig.md

@@ -32,20 +32,6 @@ How often to check for entity updates in minutes.
 
 ***
 
-### isTrustedNode?
-
-> `optional` **isTrustedNode**: `boolean`
-
-Is this a node that has permission to write to the verifiable storage?
-
-#### Default
-
-```ts
-false
-```
-
-***
-
 ### consolidationIntervalMinutes?
 
 > `optional` **consolidationIntervalMinutes**: `number`

package/docs/reference/interfaces/ISynchronisedStorageServiceConstructorOptions.md

@@ -103,6 +103,7 @@ task-scheduler
 > `optional` **trustedSynchronisedStorageComponentType**: `string`
 
 The synchronised entity storage component type to use if this node is not trusted.
+If this is set, this node uses it as the trusted node to store changesets.
 
 ***
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/synchronised-storage-service",
-	"version": "0.0.1-next.7",
+	"version": "0.0.1-next.9",
 	"description": "Synchronised storage contract implementation and REST endpoint definitions",
 	"repository": {
 		"type": "git",
@@ -26,7 +26,7 @@
 		"@twin.org/logging-models": "next",
 		"@twin.org/nameof": "next",
 		"@twin.org/standards-w3c-did": "next",
-		"@twin.org/synchronised-storage-models": "0.0.1-next.7",
+		"@twin.org/synchronised-storage-models": "0.0.1-next.9",
 		"@twin.org/verifiable-storage-models": "next",
 		"@twin.org/web": "next"
 	},