@twin.org/node-core 0.0.2-next.2 → 0.0.2-next.4

package/dist/esm/index.mjs

@@ -1,7 +1,8 @@
 import { PasswordHelper } from '@twin.org/api-auth-entity-storage-service';
 import { I18n, Is, Converter, RandomHelper, StringHelper, Coerce, Urn, GeneralError, ErrorHelper, EnvHelper } from '@twin.org/core';
 import { PasswordGenerator, Bip39 } from '@twin.org/crypto';
-import { WalletConnectorType, IdentityConnectorType, EntityStorageConnectorType, BlobStorageConnectorType, BlobStorageComponentType, VaultConnectorType, DltConfigType, LoggingConnectorType, LoggingComponentType, BackgroundTaskConnectorType, EventBusConnectorType, EventBusComponentType, TelemetryConnectorType, TelemetryComponentType, MessagingEmailConnectorType, MessagingSmsConnectorType, MessagingPushNotificationConnectorType, MessagingComponentType, FaucetConnectorType, NftConnectorType, NftComponentType, VerifiableStorageConnectorType, VerifiableStorageComponentType, ImmutableProofComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, IdentityComponentType, IdentityResolverConnectorType, IdentityResolverComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, AttestationConnectorType, AttestationComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DocumentManagementComponentType, FederatedCatalogueComponentType, RightsManagementPapComponentType, RightsManagementComponentType, TaskSchedulerComponentType } from '@twin.org/engine-types';
+import { AuthenticationComponentType, InformationComponentType, RestRouteProcessorType, SocketRouteProcessorType, AuthenticationAdminComponentType } from '@twin.org/engine-server-types';
+import { WalletConnectorType, IdentityConnectorType, EntityStorageConnectorType, BlobStorageConnectorType, BlobStorageComponentType, VaultConnectorType, DltConfigType, LoggingConnectorType, LoggingComponentType, BackgroundTaskConnectorType, EventBusConnectorType, EventBusComponentType, TelemetryConnectorType, TelemetryComponentType, MessagingEmailConnectorType, MessagingSmsConnectorType, MessagingPushNotificationConnectorType, MessagingComponentType, FaucetConnectorType, NftConnectorType, NftComponentType, VerifiableStorageConnectorType, VerifiableStorageComponentType, ImmutableProofComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, IdentityComponentType, IdentityResolverConnectorType, IdentityResolverComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, AttestationConnectorType, AttestationComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DocumentManagementComponentType, RightsManagementPapComponentType, RightsManagementComponentType, TaskSchedulerComponentType, SynchronisedStorageComponentType, FederatedCatalogueComponentType } from '@twin.org/engine-types';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { IdentityProfileConnectorFactory, IdentityConnectorFactory, IdentityResolverConnectorFactory, DocumentHelper } from '@twin.org/identity-models';
 import { VaultConnectorFactory, VaultKeyType } from '@twin.org/vault-models';
@@ -9,7 +10,6 @@ import { WalletConnectorFactory } from '@twin.org/wallet-models';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { addDefaultRestPaths, addDefaultSocketPaths, EngineServer } from '@twin.org/engine-server';
-import { InformationComponentType, RestRouteProcessorType, SocketRouteProcessorType, AuthenticationAdminComponentType, AuthenticationComponentType } from '@twin.org/engine-server-types';
 import * as dotenv from 'dotenv';
 import { Engine } from '@twin.org/engine';
 import { FileStateStorage } from '@twin.org/engine-core';
@@ -29,7 +29,11 @@ const NodeFeatures = {
     /**
      * NodeUser - generates a user for the node if not provided in config.
      */
-    NodeUser: "node-user"
+    NodeUser: "node-user",
+    /**
+     * NodeWallet - generates a wallet for the node and funds it when there is a faucet available.
+     */
+    NodeWallet: "node-wallet"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -116,8 +120,9 @@ async function bootstrap(engineCore, context, envVars) {
     await bootstrapNodeUser(engineCore, context, envVars, features);
     await bootstrapAuth(engineCore, context, envVars);
     await bootstrapBlobEncryption(engineCore, context, envVars);
-    await bootstrapAttestationMethod(engineCore, context, envVars);
-    await bootstrapImmutableProofMethod(engineCore, context, envVars);
+    await addVerificationMethod(engineCore, context, "attestation", envVars.attestationVerificationMethodId);
+    await addVerificationMethod(engineCore, context, "immutable proof", envVars.immutableProofVerificationMethodId);
+    await bootstrapSynchronisedStorage(engineCore, context, envVars);
 }
 /**
  * Bootstrap the node creating any necessary resources.
@@ -132,23 +137,21 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
         // But we have a chicken and egg problem in that we can't create the identity
         // to store the mnemonic in the vault without an identity. We use a temporary identity
         // and then replace it with the new identity later in the process.
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        if (!Is.empty(engineDefaultTypes.vaultConnector)) {
-            const vaultConnector = VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-            const workingIdentity = envVars.identity ??
-                context.state.nodeIdentity ??
-                `bootstrap-temp-${Converter.bytesToHex(RandomHelper.generate(16))}`;
-            await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
-            const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
-            const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
-            await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
-            await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
-            context.state.nodeIdentity = finalIdentity;
-            context.stateDirty = true;
-            engineCore.logInfo(I18n.formatMessage("node.nodeIdentity", {
-                identity: context.state.nodeIdentity
-            }));
-        }
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
+        const workingIdentity = envVars.identity ??
+            context.state.nodeIdentity ??
+            `bootstrap-temp-${Converter.bytesToHex(RandomHelper.generate(16))}`;
+        await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
+        const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
+        const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
+        await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
+        await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
+        context.state.nodeIdentity = finalIdentity;
+        context.stateDirty = true;
+        engineCore.logInfo(I18n.formatMessage("node.nodeIdentity", {
+            identity: context.state.nodeIdentity
+        }));
     }
 }
 /**
@@ -160,12 +163,13 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
  * @returns The addresses for the wallet.
  */
 async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
+    const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
     // Now create an identity for the node controlled by the address we just funded
-    const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+    const identityConnector = IdentityConnectorFactory.get(defaultIdentityConnectorType);
     let identityDocument;
     try {
-        const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
         identityDocument = await identityResolverConnector.resolveDocument(nodeIdentity);
         engineCore.logInfo(I18n.formatMessage("node.existingNodeIdentity", { identity: nodeIdentity }));
     }
@@ -175,7 +179,7 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
         identityDocument = await identityConnector.createDocument(nodeIdentity);
         engineCore.logInfo(I18n.formatMessage("node.createdNodeIdentity", { identity: identityDocument.id }));
     }
-    if (engineDefaultTypes.identityConnector === IdentityConnectorType.Iota) {
+    if (defaultIdentityConnectorType.startsWith(IdentityConnectorType.Iota)) {
         const didUrn = Urn.fromValidString(identityDocument.id);
         const didParts = didUrn.parts();
         const objectId = didParts[3];
@@ -194,23 +198,26 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
  * @returns The addresses for the wallet.
  */
 async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    const walletConnector = WalletConnectorFactory.get(engineDefaultTypes.walletConnector);
-    const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
-    const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
-    if (balance === 0n) {
-        let address0 = addresses[0];
-        if (engineDefaultTypes.walletConnector === WalletConnectorType.Iota) {
-            address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        const walletConnector = WalletConnectorFactory.get(defaultWalletConnectorType);
+        const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
+        const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
+        if (balance === 0n) {
+            let address0 = addresses[0];
+            if (defaultWalletConnectorType.startsWith(WalletConnectorType.Iota)) {
+                address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+            }
+            engineCore.logInfo(I18n.formatMessage("node.fundingWallet", { address: address0 }));
+            // Add some funds to the wallet from the faucet
+            await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
         }
-        engineCore.logInfo(I18n.formatMessage("node.fundingWallet", { address: address0 }));
-        // Add some funds to the wallet from the faucet
-        await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
-    }
-    else {
-        engineCore.logInfo(I18n.formatMessage("node.fundedWallet"));
+        else {
+            engineCore.logInfo(I18n.formatMessage("node.fundedWallet"));
+        }
+        return addresses;
     }
-    return addresses;
+    return [];
 }
 /**
  * Bootstrap the identity for the node.
@@ -221,15 +228,17 @@ async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
  * @param addresses The addresses for the wallet.
  */
 async function finaliseWallet(engineCore, envVars, features, finalIdentity, addresses) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    // If we are using entity storage for wallet the identity associated with the
-    // address will be wrong, so fix it
-    if (engineDefaultTypes.walletConnector === "entity-storage") {
-        const walletAddress = EntityStorageConnectorFactory.get(StringHelper.kebabCase("WalletAddress"));
-        const addr = await walletAddress.get(addresses[0]);
-        if (!Is.empty(addr)) {
-            addr.identity = finalIdentity;
-            await walletAddress.set(addr);
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        // If we are using entity storage for wallet the identity associated with the
+        // address will be wrong, so fix it
+        if (defaultWalletConnectorType.startsWith(WalletConnectorType.EntityStorage)) {
+            const walletAddress = EntityStorageConnectorFactory.get(StringHelper.kebabCase("WalletAddress"));
+            const addr = await walletAddress.get(addresses[0]);
+            if (!Is.empty(addr)) {
+                addr.identity = finalIdentity;
+                await walletAddress.set(addr);
+            }
         }
     }
 }
@@ -291,8 +300,8 @@ async function finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity)
  */
 async function bootstrapNodeUser(engineCore, context, envVars, features) {
     if (features.includes(NodeFeatures.NodeUser)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+        const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceType("authenticationComponent");
+        if (defaultAuthenticationComponentType.startsWith(AuthenticationComponentType.EntityStorage) &&
             Is.stringValue(context.state.nodeIdentity)) {
             const authUserEntityStorage = EntityStorageConnectorFactory.get(StringHelper.kebabCase("AuthenticationUser"));
             const email = envVars.username ?? DEFAULT_NODE_USERNAME;
@@ -335,7 +344,8 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
                 }
             }
             // We have create a node user, now we need to create a profile for the user
-            const identityProfileConnector = IdentityProfileConnectorFactory.get(engineDefaultTypes.identityProfileConnector);
+            const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+            const identityProfileConnector = IdentityProfileConnectorFactory.get(defaultIdentityConnectorType);
             if (identityProfileConnector) {
                 let userProfile;
                 try {
@@ -365,43 +375,6 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
         }
     }
 }
-/**
- * Bootstrap the attestation verification methods.
- * @param engineCore The engine core for the node.
- * @param context The context for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- */
-async function bootstrapAttestationMethod(engineCore, context, envVars, features) {
-    if (Is.stringValue(context.state.nodeIdentity) &&
-        Is.arrayValue(context.config.types.identityConnector) &&
-        Is.stringValue(envVars.attestationVerificationMethodId)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.attestationVerificationMethodId}`;
-        let createVm = true;
-        try {
-            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            createVm = false;
-        }
-        catch { }
-        if (createVm) {
-            // Add attestation verification method to DID, the correct node context is now in place
-            // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(I18n.formatMessage("node.addingAttestation", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.attestationVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(I18n.formatMessage("node.existingAttestation", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
 /**
  * Bootstrap the immutable proof verification methods.
  * @param engineCore The engine core for the node.
@@ -409,36 +382,7 @@ async function bootstrapAttestationMethod(engineCore, context, envVars, features
  * @param envVars The environment variables for the node.
  * @param features The features that are enabled on the node.
  */
-async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    if (Is.stringValue(context.state.nodeIdentity) &&
-        Is.arrayValue(context.config.types.identityConnector) &&
-        Is.stringValue(envVars.immutableProofVerificationMethodId)) {
-        const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`;
-        let createVm = true;
-        try {
-            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            createVm = false;
-        }
-        catch { }
-        if (createVm) {
-            // Add AIG verification method to DID, the correct node context is now in place
-            // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(I18n.formatMessage("node.addingImmutableProof", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.immutableProofVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(I18n.formatMessage("node.existingImmutableProof", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
+async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) { }
 /**
  * Bootstrap the keys for blob encryption.
  * @param engineCore The engine core for the node.
@@ -449,18 +393,28 @@ async function bootstrapImmutableProofMethod(engineCore, context, envVars, featu
 async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
     if ((Coerce.boolean(envVars.blobStorageEnableEncryption) ?? false) &&
         Is.stringValue(context.state.nodeIdentity)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
         // Create a new key for encrypting blobs
-        const vaultConnector = VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`;
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
+        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKeyId}`;
         let existingKey;
         try {
             existingKey = await vaultConnector.getKey(keyName);
         }
         catch { }
         if (Is.empty(existingKey)) {
-            engineCore.logInfo(I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
-            await vaultConnector.createKey(keyName, VaultKeyType.ChaCha20Poly1305);
+            if (Is.stringBase64(envVars.blobStorageSymmetricEncryptionKey)) {
+                engineCore.logInfo(I18n.formatMessage("node.addingBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, VaultKeyType.ChaCha20Poly1305, Converter.base64ToBytes(envVars.blobStorageSymmetricEncryptionKey));
+            }
+            else {
+                engineCore.logInfo(I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
+                const key = await vaultConnector.createKey(keyName, VaultKeyType.ChaCha20Poly1305);
+                engineCore.logInfo(I18n.formatMessage("node.createdBlobEncryptionKey", {
+                    keyName,
+                    keyValue: Converter.bytesToBase64(key)
+                }));
+            }
         }
         else {
             engineCore.logInfo(I18n.formatMessage("node.existingBlobEncryptionKey", { keyName }));
@@ -475,11 +429,13 @@ async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
  * @param features The features that are enabled on the node.
  */
 async function bootstrapAuth(engineCore, context, envVars, features) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+    const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceTypeOptional("authenticationComponent");
+    if (Is.stringValue(defaultAuthenticationComponentType) &&
+        defaultAuthenticationComponentType.startsWith(AuthenticationComponentType.EntityStorage) &&
         Is.stringValue(context.state.nodeIdentity)) {
         // Create a new JWT signing key and a user login for the node
-        const vaultConnector = VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
         const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId}`;
         let existingKey;
         try {
@@ -495,6 +451,77 @@ async function bootstrapAuth(engineCore, context, envVars, features) {
         }
     }
 }
+/**
+ * Bootstrap the synchronised storage blob encryption and verification methods.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapSynchronisedStorage(engineCore, context, envVars, features) {
+    if (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) {
+        // Add the verification method to the identity if it doesn't exist
+        await addVerificationMethod(engineCore, context, "synchronised storage", envVars.synchronisedStorageVerificationMethodId);
+        // If this is a trusted node we need to add the blob encryption key pair
+        if (Is.stringValue(envVars.synchronisedStorageBlobStorageEncryptionKeyId) &&
+            Is.stringBase64(envVars.synchronisedStorageBlobStoragePrivateKey) &&
+            Is.stringBase64(envVars.synchronisedStorageBlobStoragePublicKey)) {
+            const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+            const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
+            const keyName = envVars.synchronisedStorageBlobStorageEncryptionKeyId;
+            let existingKey;
+            try {
+                existingKey = await vaultConnector.getKey(keyName);
+            }
+            catch { }
+            if (Is.empty(existingKey)) {
+                engineCore.logInfo(I18n.formatMessage("node.addingSynchronisedStorageBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, VaultKeyType.Rsa2048, Converter.base64ToBytes(envVars.synchronisedStorageBlobStoragePrivateKey), Converter.base64ToBytes(envVars.synchronisedStorageBlobStoragePublicKey));
+            }
+            else {
+                engineCore.logInfo(I18n.formatMessage("node.existingSynchronisedStorageBlobEncryptionKey", { keyName }));
+            }
+        }
+    }
+}
+/**
+ * Add a verification method if it doesn't exist.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param verificationMethodTitle The verification method title.
+ * @param verificationMethodId The verification method ID.
+ */
+async function addVerificationMethod(engineCore, context, verificationMethodTitle, verificationMethodId) {
+    if (Is.stringValue(context.state.nodeIdentity) &&
+        Is.arrayValue(context.config.types.identityConnector) &&
+        Is.stringValue(verificationMethodId)) {
+        const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+        const identityConnector = IdentityConnectorFactory.get(defaultIdentityConnectorType);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
+        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        const fullMethodId = `${identityDocument.id}#${verificationMethodId}`;
+        let exists = false;
+        try {
+            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
+            exists = true;
+        }
+        catch { }
+        if (!exists) {
+            engineCore.logInfo(I18n.formatMessage("node.addingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", verificationMethodId);
+        }
+        else {
+            engineCore.logInfo(I18n.formatMessage("node.existingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+        }
+    }
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -512,7 +539,9 @@ function buildEngineConfiguration(envVars) {
     envVars.attestationVerificationMethodId ??= "attestation-assertion";
     envVars.immutableProofVerificationMethodId ??= "immutable-proof-assertion";
     envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    envVars.blobStorageEncryptionKeyId ??= "blob-encryption";
+    envVars.synchronisedStorageBlobStorageEncryptionKeyId ??= "synchronised-storage-blob-encryption";
+    envVars.synchronisedStorageVerificationMethodId ??= "synchronised-storage-assertion";
     const coreConfig = {
         debug: Coerce.boolean(envVars.debug) ?? false,
         types: {}
@@ -538,9 +567,10 @@ function buildEngineConfiguration(envVars) {
     configureAuditableItemGraph(coreConfig);
     configureAuditableItemStream(coreConfig);
     configureDocumentManagement(coreConfig);
-    configureFederatedCatalogue(coreConfig, envVars);
     configureRightsManagement(coreConfig, envVars);
     configureTaskScheduler(coreConfig, envVars);
+    configureSynchronisedStorage(coreConfig, envVars);
+    configureFederatedCatalogue(coreConfig, envVars);
     return coreConfig;
 }
 /**
@@ -662,7 +692,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (entityStorageConnectorTypes) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.PostgreSql)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.PostgreSql,
             options: {
@@ -677,10 +707,19 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
+    const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Synchronised)) {
+        // For synchronised storage we use the default connector as the one we wrap for real DB operations
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.Synchronised,
+            options: {
+                entityStorageConnectorType: defaultEntityStorageConnectorType
+            }
+        });
+    }
     if (Is.arrayValue(entityStorageConnectorTypes)) {
-        const defaultStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
         for (const config of coreConfig.types.entityStorageConnector) {
-            if (config.type === defaultStorageConnectorType) {
+            if (config.type === defaultEntityStorageConnectorType) {
                 config.isDefault = true;
                 break;
             }
@@ -772,6 +811,13 @@ function configureBlobStorage(coreConfig, envVars) {
         for (const config of coreConfig.types.blobStorageConnector) {
             if (config.type === defaultStorageConnectorType) {
                 config.isDefault = true;
+            }
+            // If this blob storage connector is the one to use for public access
+            // then add it as a feature
+            if (Is.stringValue(envVars.blobStorageConnectorPublic) &&
+                config.type === envVars.blobStorageConnectorPublic) {
+                config.features ??= [];
+                config.features.push("public");
                 break;
             }
         }
@@ -783,7 +829,7 @@ function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? envVars.blobStorageEncryptionKey
+                        ? envVars.blobStorageEncryptionKeyId
                         : undefined
                 }
             }
@@ -1277,25 +1323,6 @@ function configureDocumentManagement(coreConfig, envVars) {
         });
     }
 }
-/**
- * Configures the federated catalogue.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureFederatedCatalogue(coreConfig, envVars) {
-    if (Is.arrayValue(coreConfig.types.identityResolverComponent)) {
-        coreConfig.types.federatedCatalogueComponent ??= [];
-        coreConfig.types.federatedCatalogueComponent.push({
-            type: FederatedCatalogueComponentType.Service,
-            options: {
-                config: {
-                    subResourceCacheTtlMs: Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
-                }
-            }
-        });
-    }
-}
 /**
  * Configures the rights management.
  * @param coreConfig The core config.
@@ -1319,10 +1346,73 @@ function configureRightsManagement(coreConfig, envVars) {
  * @param envVars The environment variables.
  */
 function configureTaskScheduler(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? true) {
+    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
         coreConfig.types.taskSchedulerComponent ??= [];
         coreConfig.types.taskSchedulerComponent.push({
-            type: TaskSchedulerComponentType.Default
+            type: TaskSchedulerComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the synchronised storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureSynchronisedStorage(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.identityResolverComponent) &&
+        (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false)) {
+        // Check if the config provides a custom verifiable storage key id
+        let verifiableStorageKeyId = Coerce.string(envVars.synchronisedStorageVerifiableStorageKeyId);
+        if (!Is.stringValue(verifiableStorageKeyId)) {
+            // No custom key so default to the network setting
+            verifiableStorageKeyId = envVars.iotaNetwork;
+        }
+        coreConfig.types.synchronisedStorageComponent ??= [];
+        coreConfig.types.synchronisedStorageComponent.push({
+            type: SynchronisedStorageComponentType.Service,
+            options: {
+                config: {
+                    verifiableStorageKeyId: verifiableStorageKeyId ?? "",
+                    synchronisedStorageMethodId: envVars.synchronisedStorageVerificationMethodId,
+                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId,
+                    entityUpdateIntervalMinutes: Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
+                    consolidationIntervalMinutes: Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
+                    consolidationBatchSize: Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
+                    maxConsolidations: Coerce.number(envVars.synchronisedStorageMaxConsolidations)
+                }
+            }
+        });
+        // If there is a trusted url set, we need to add a client
+        // and give it a feature of trusted so that when the synchronised
+        // storage is created it can pickup the correct component
+        if (Is.stringValue(envVars.synchronisedStorageTrustedUrl)) {
+            coreConfig.types.synchronisedStorageComponent.push({
+                type: SynchronisedStorageComponentType.RestClient,
+                options: {
+                    endpoint: envVars.synchronisedStorageTrustedUrl
+                },
+                features: ["trusted"]
+            });
+        }
+    }
+}
+/**
+ * Configures the federated catalogue.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFederatedCatalogue(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.identityResolverComponent) &&
+        (Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false)) {
+        coreConfig.types.federatedCatalogueComponent ??= [];
+        coreConfig.types.federatedCatalogueComponent.push({
+            type: FederatedCatalogueComponentType.Service,
+            options: {
+                config: {
+                    subResourceCacheTtlMs: Coerce.number(envVars.federatedCatalogueCacheTtlMs),
+                    clearingHouseApproverList: Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                }
+            }
         });
     }
 }
@@ -1511,9 +1601,10 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
  * @returns The engine server.
  */
 async function start(nodeOptions, engineServerConfig, envVars) {
-    envVars.storageFileRoot ??= "";
     const entityStorageConnectorType = envVars.entityStorageConnectorType?.split(",") ?? [];
     const blobStorageConnectorType = envVars.blobStorageConnectorType?.split(",") ?? [];
+    // If the blob storage or entity storage is configured with file connectors
+    // then we need to make sure the storageFileRoot is set
     if ((entityStorageConnectorType.includes(EntityStorageConnectorType.File) ||
         blobStorageConnectorType.includes(BlobStorageConnectorType.File) ||
         Is.empty(nodeOptions?.stateStorage)) &&
@@ -1522,7 +1613,7 @@ async function start(nodeOptions, engineServerConfig, envVars) {
             storageFileRoot: `${nodeOptions?.envPrefix ?? ""}_STORAGE_FILE_ROOT`
         });
     }
-    // Create the engine instance using file state storage and custom bootstrap.
+    // Create the engine instance using file state storage unless one is configured in options
     const engine = new Engine({
         config: engineServerConfig,
         stateStorage: nodeOptions?.stateStorage ?? new FileStateStorage(envVars.stateFilename ?? ""),
@@ -1566,7 +1657,7 @@ async function run(nodeOptions) {
         nodeOptions ??= {};
         const serverInfo = {
             name: nodeOptions?.serverName ?? "TWIN Node Server",
-            version: nodeOptions?.serverVersion ?? "0.0.2-next.2" // x-release-please-version
+            version: nodeOptions?.serverVersion ?? "0.0.2-next.4" // x-release-please-version
         };
         console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
         if (!Is.stringValue(nodeOptions?.executionDirectory)) {
@@ -1624,7 +1715,8 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     if (Is.arrayValue(options?.envFilenames)) {
         const output = dotenv.config({
-            path: options?.envFilenames
+            path: options?.envFilenames,
+            quiet: true
         });
         // We don't want to throw an error if the default environment file is not found.
         // Only if we have custom environment files.
@@ -1676,4 +1768,4 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     return { engineServerConfig, nodeEnvVars: envVars };
 }
 
-export { NodeFeatures, bootstrap, bootstrapAttestationMethod, bootstrapAuth, bootstrapBlobEncryption, bootstrapImmutableProofMethod, bootstrapNodeIdentity, bootstrapNodeUser, buildConfiguration, buildEngineConfiguration, buildEngineServerConfiguration, fileExists, getExecutionDirectory, getFeatures, initialiseLocales, loadJsonFile, run, start };
+export { NodeFeatures, bootstrap, bootstrapAuth, bootstrapBlobEncryption, bootstrapImmutableProofMethod, bootstrapNodeIdentity, bootstrapNodeUser, bootstrapSynchronisedStorage, buildConfiguration, buildEngineConfiguration, buildEngineServerConfiguration, fileExists, getExecutionDirectory, getFeatures, initialiseLocales, loadJsonFile, run, start };