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

package/dist/cjs/index.cjs

@@ -3,6 +3,7 @@
 var apiAuthEntityStorageService = require('@twin.org/api-auth-entity-storage-service');
 var core = require('@twin.org/core');
 var crypto = require('@twin.org/crypto');
+var engineServerTypes = require('@twin.org/engine-server-types');
 var engineTypes = require('@twin.org/engine-types');
 var entityStorageModels = require('@twin.org/entity-storage-models');
 var identityModels = require('@twin.org/identity-models');
@@ -10,8 +11,10 @@ var vaultModels = require('@twin.org/vault-models');
 var walletModels = require('@twin.org/wallet-models');
 var promises = require('node:fs/promises');
 var path = require('node:path');
+var cliCore = require('@twin.org/cli-core');
+var rightsManagementRestClient = require('@twin.org/rights-management-rest-client');
 var engineServer = require('@twin.org/engine-server');
-var engineServerTypes = require('@twin.org/engine-server-types');
+var modules = require('@twin.org/modules');
 var dotenv = require('dotenv');
 var engine = require('@twin.org/engine');
 var engineCore = require('@twin.org/engine-core');
@@ -36,6 +39,15 @@ function _interopNamespaceDefault(e) {
 
 var dotenv__namespace = /*#__PURE__*/_interopNamespaceDefault(dotenv);
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+const ATTESTATION_VERIFICATION_METHOD_ID = "attestation-assertion";
+const IMMUTABLE_PROOF_VERIFICATION_METHOD_ID = "immutable-proof-assertion";
+const BLOB_STORAGE_ENCRYPTION_KEY_ID = "blob-encryption";
+const SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID = "synchronised-storage-blob-encryption";
+const VC_AUTHENTICATION_VERIFICATION_METHOD_ID = "node-authentication-assertion";
+const AUTH_SIGNING_KEY_ID = "auth-signing";
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -50,25 +62,28 @@ 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.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-console */
 /**
  * Initialise the locales for the application.
  * @param localesDirectory The directory containing the locales.
  */
 async function initialiseLocales(localesDirectory) {
     const localesFile = path.resolve(path.join(localesDirectory, "en.json"));
-    console.info("Locales File:", localesFile);
+    cliCore.CLIDisplay.value("Locales File", localesFile);
     if (await fileExists(localesFile)) {
         const enLangContent = await promises.readFile(localesFile, "utf8");
         core.I18n.addDictionary("en", JSON.parse(enLangContent));
     }
     else {
-        console.warn(`Locales file not found: ${localesFile}`);
+        cliCore.CLIDisplay.error(`Locales file not found: ${localesFile}`);
     }
 }
 /**
@@ -92,13 +107,79 @@ async function fileExists(filename) {
         return false;
     }
 }
+/**
+ * Does the specified directory exist.
+ * @param directory The directory to check for existence.
+ * @returns True if the directory exists.
+ */
+async function directoryExists(directory) {
+    try {
+        const stats = await promises.stat(directory);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the sub folders for the folder.
+ * @param directory The directory to get the sub folders.
+ * @returns The list of sub folders.
+ */
+async function getSubFolders(directory) {
+    try {
+        const dir = await promises.readdir(directory);
+        const folders = [];
+        for (const dirEntry of dir) {
+            const fullPath = path.join(directory, dirEntry);
+            const stats = await promises.stat(fullPath);
+            if (stats.isDirectory()) {
+                folders.push(fullPath);
+            }
+        }
+        return folders;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the files in the directory.
+ * @param directory The directory to get the files from.
+ * @returns The list of files in the directory.
+ */
+async function getFiles(directory) {
+    try {
+        const dir = await promises.readdir(directory);
+        const files = [];
+        for (const dirEntry of dir) {
+            const fullPath = path.join(directory, dirEntry);
+            const stats = await promises.stat(fullPath);
+            if (stats.isFile()) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load the text file.
+ * @param filename The filename of the text file to load.
+ * @returns The contents of the text file if it could not be loaded.
+ */
+async function loadTextFile(filename) {
+    return promises.readFile(filename, "utf8");
+}
 /**
  * Load the JSON file.
  * @param filename The filename of the JSON file to load.
  * @returns The contents of the JSON file or null if it could not be loaded.
  */
 async function loadJsonFile(filename) {
-    const content = await promises.readFile(filename, "utf8");
+    const content = await loadTextFile(filename);
     return JSON.parse(content);
 }
 /**
@@ -137,8 +218,18 @@ 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);
+    const defaultAttestationConnectorType = engineCore.getRegisteredInstanceTypeOptional("attestationConnector");
+    if (!core.Is.empty(defaultAttestationConnectorType)) {
+        await addVerificationMethod(engineCore, context, "attestation", envVars.attestationVerificationMethodId ?? ATTESTATION_VERIFICATION_METHOD_ID);
+    }
+    const defaultImmutableProofComponentType = engineCore.getRegisteredInstanceTypeOptional("immutableProofComponent");
+    if (!core.Is.empty(defaultImmutableProofComponentType)) {
+        await addVerificationMethod(engineCore, context, "immutable proof", envVars.immutableProofVerificationMethodId ?? IMMUTABLE_PROOF_VERIFICATION_METHOD_ID);
+    }
+    if (core.Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
+        await addVerificationMethod(engineCore, context, "verifiable credential authentication", envVars.vcAuthenticationVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID);
+    }
+    await bootstrapSynchronisedStorage(engineCore, context, envVars);
 }
 /**
  * Bootstrap the node creating any necessary resources.
@@ -153,23 +244,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 (!core.Is.empty(engineDefaultTypes.vaultConnector)) {
-            const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-            const workingIdentity = envVars.identity ??
-                context.state.nodeIdentity ??
-                `bootstrap-temp-${core.Converter.bytesToHex(core.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(core.I18n.formatMessage("node.nodeIdentity", {
-                identity: context.state.nodeIdentity
-            }));
-        }
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+        const workingIdentity = envVars.identity ??
+            context.state.nodeIdentity ??
+            `bootstrap-temp-${core.Converter.bytesToHex(core.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(core.I18n.formatMessage("node.nodeIdentity", {
+            identity: context.state.nodeIdentity
+        }));
     }
 }
 /**
@@ -181,12 +270,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 = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+    const identityConnector = identityModels.IdentityConnectorFactory.get(defaultIdentityConnectorType);
     let identityDocument;
     try {
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
         identityDocument = await identityResolverConnector.resolveDocument(nodeIdentity);
         engineCore.logInfo(core.I18n.formatMessage("node.existingNodeIdentity", { identity: nodeIdentity }));
     }
@@ -196,7 +286,7 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
         identityDocument = await identityConnector.createDocument(nodeIdentity);
         engineCore.logInfo(core.I18n.formatMessage("node.createdNodeIdentity", { identity: identityDocument.id }));
     }
-    if (engineDefaultTypes.identityConnector === engineTypes.IdentityConnectorType.Iota) {
+    if (defaultIdentityConnectorType.startsWith(engineTypes.IdentityConnectorType.Iota)) {
         const didUrn = core.Urn.fromValidString(identityDocument.id);
         const didParts = didUrn.parts();
         const objectId = didParts[3];
@@ -215,23 +305,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 = walletModels.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 === engineTypes.WalletConnectorType.Iota) {
-            address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        const walletConnector = walletModels.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(engineTypes.WalletConnectorType.Iota)) {
+                address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+            }
+            engineCore.logInfo(core.I18n.formatMessage("node.fundingWallet", { address: address0 }));
+            // Add some funds to the wallet from the faucet
+            await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
         }
-        engineCore.logInfo(core.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(core.I18n.formatMessage("node.fundedWallet"));
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.fundedWallet"));
+        }
+        return addresses;
     }
-    return addresses;
+    return [];
 }
 /**
  * Bootstrap the identity for the node.
@@ -242,15 +335,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 = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("WalletAddress"));
-        const addr = await walletAddress.get(addresses[0]);
-        if (!core.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(engineTypes.WalletConnectorType.EntityStorage)) {
+            const walletAddress = entityStorageModels.EntityStorageConnectorFactory.get("wallet-address");
+            const addr = await walletAddress.get(addresses[0]);
+            if (!core.Is.empty(addr)) {
+                addr.identity = finalIdentity;
+                await walletAddress.set(addr);
+            }
         }
     }
 }
@@ -312,10 +407,10 @@ 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(engineServerTypes.AuthenticationComponentType.EntityStorage) &&
             core.Is.stringValue(context.state.nodeIdentity)) {
-            const authUserEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("AuthenticationUser"));
+            const authUserEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get("authentication-user");
             const email = envVars.username ?? DEFAULT_NODE_USERNAME;
             let nodeAdminUser = await authUserEntityStorage.get(email);
             if (core.Is.empty(nodeAdminUser)) {
@@ -356,7 +451,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 = identityModels.IdentityProfileConnectorFactory.get(engineDefaultTypes.identityProfileConnector);
+            const defaultIdentityProfileConnectorType = engineCore.getRegisteredInstanceType("identityProfileConnector");
+            const identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(defaultIdentityProfileConnectorType);
             if (identityProfileConnector) {
                 let userProfile;
                 try {
@@ -386,43 +482,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 (core.Is.stringValue(context.state.nodeIdentity) &&
-        core.Is.arrayValue(context.config.types.identityConnector) &&
-        core.Is.stringValue(envVars.attestationVerificationMethodId)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.attestationVerificationMethodId}`;
-        let createVm = true;
-        try {
-            identityModels.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(core.I18n.formatMessage("node.addingAttestation", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.attestationVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(core.I18n.formatMessage("node.existingAttestation", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
 /**
  * Bootstrap the immutable proof verification methods.
  * @param engineCore The engine core for the node.
@@ -430,36 +489,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 (core.Is.stringValue(context.state.nodeIdentity) &&
-        core.Is.arrayValue(context.config.types.identityConnector) &&
-        core.Is.stringValue(envVars.immutableProofVerificationMethodId)) {
-        const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`;
-        let createVm = true;
-        try {
-            identityModels.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(core.I18n.formatMessage("node.addingImmutableProof", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.immutableProofVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(core.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.
@@ -470,18 +500,28 @@ async function bootstrapImmutableProofMethod(engineCore, context, envVars, featu
 async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
     if ((core.Coerce.boolean(envVars.blobStorageEnableEncryption) ?? false) &&
         core.Is.stringValue(context.state.nodeIdentity)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
         // Create a new key for encrypting blobs
-        const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`;
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKeyId ?? BLOB_STORAGE_ENCRYPTION_KEY_ID}`;
         let existingKey;
         try {
             existingKey = await vaultConnector.getKey(keyName);
         }
         catch { }
         if (core.Is.empty(existingKey)) {
-            engineCore.logInfo(core.I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
-            await vaultConnector.createKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305);
+            if (core.Is.stringBase64(envVars.blobStorageSymmetricEncryptionKey)) {
+                engineCore.logInfo(core.I18n.formatMessage("node.addingBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305, core.Converter.base64ToBytes(envVars.blobStorageSymmetricEncryptionKey));
+            }
+            else {
+                engineCore.logInfo(core.I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
+                const key = await vaultConnector.createKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305);
+                engineCore.logInfo(core.I18n.formatMessage("node.createdBlobEncryptionKey", {
+                    keyName,
+                    keyValue: core.Converter.bytesToBase64(key)
+                }));
+            }
         }
         else {
             engineCore.logInfo(core.I18n.formatMessage("node.existingBlobEncryptionKey", { keyName }));
@@ -496,12 +536,14 @@ 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 (core.Is.stringValue(defaultAuthenticationComponentType) &&
+        defaultAuthenticationComponentType.startsWith(engineServerTypes.AuthenticationComponentType.EntityStorage) &&
         core.Is.stringValue(context.state.nodeIdentity)) {
         // Create a new JWT signing key and a user login for the node
-        const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-        const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId}`;
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+        const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID}`;
         let existingKey;
         try {
             existingKey = await vaultConnector.getKey(keyName);
@@ -516,6 +558,74 @@ 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 (core.Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) {
+        // If this is a trusted node we need to add the blob encryption key pair
+        if (core.Is.stringBase64(envVars.synchronisedStorageBlobStorageKey)) {
+            const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+            const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+            const keyName = envVars.synchronisedStorageBlobStorageEncryptionKeyId ??
+                SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID;
+            let existingKey;
+            try {
+                existingKey = await vaultConnector.getKey(keyName);
+            }
+            catch { }
+            if (core.Is.empty(existingKey)) {
+                engineCore.logInfo(core.I18n.formatMessage("node.addingSynchronisedStorageBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305, core.Converter.base64ToBytes(envVars.synchronisedStorageBlobStorageKey));
+            }
+            else {
+                engineCore.logInfo(core.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 (core.Is.stringValue(context.state.nodeIdentity) &&
+        core.Is.arrayValue(context.config.types.identityConnector) &&
+        core.Is.stringValue(verificationMethodId)) {
+        const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+        const identityConnector = identityModels.IdentityConnectorFactory.get(defaultIdentityConnectorType);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
+        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        const fullMethodId = `${identityDocument.id}#${verificationMethodId}`;
+        let exists = false;
+        try {
+            identityModels.DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
+            exists = true;
+        }
+        catch { }
+        if (!exists) {
+            engineCore.logInfo(core.I18n.formatMessage("node.addingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", verificationMethodId);
+        }
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.existingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+        }
+    }
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -524,61 +634,51 @@ async function bootstrapAuth(engineCore, context, envVars, features) {
  * @param envVars The environment variables.
  * @returns The config for the core.
  */
-function buildEngineConfiguration(envVars) {
+async function buildEngineConfiguration(envVars) {
     if (core.Is.stringValue(envVars.storageFileRoot)) {
         envVars.stateFilename ??= "engine-state.json";
         envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
         envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
     }
-    envVars.attestationVerificationMethodId ??= "attestation-assertion";
-    envVars.immutableProofVerificationMethodId ??= "immutable-proof-assertion";
-    envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
     const coreConfig = {
         debug: core.Coerce.boolean(envVars.debug) ?? false,
         types: {}
     };
-    configureEntityStorage(coreConfig, envVars);
-    configureBlobStorage(coreConfig, envVars);
-    configureVault(coreConfig, envVars);
-    configureDlt(coreConfig, envVars);
-    configureLogging(coreConfig, envVars);
-    configureBackgroundTask(coreConfig, envVars);
-    configureEventBus(coreConfig, envVars);
-    configureTelemetry(coreConfig, envVars);
-    configureMessaging(coreConfig, envVars);
-    configureFaucet(coreConfig, envVars);
-    configureWallet(coreConfig, envVars);
-    configureNft(coreConfig, envVars);
-    configureVerifiableStorage(coreConfig, envVars);
-    configureIdentity(coreConfig, envVars);
-    configureIdentityResolver(coreConfig, envVars);
-    configureIdentityProfile(coreConfig, envVars);
-    configureAttestation(coreConfig, envVars);
-    configureDataProcessing(coreConfig, envVars);
-    configureAuditableItemGraph(coreConfig);
-    configureAuditableItemStream(coreConfig);
-    configureDocumentManagement(coreConfig);
-    configureFederatedCatalogue(coreConfig, envVars);
-    configureRightsManagement(coreConfig, envVars);
-    configureTaskScheduler(coreConfig, envVars);
+    await configureEntityStorage(coreConfig, envVars);
+    await configureBlobStorage(coreConfig, envVars);
+    await configureVault(coreConfig, envVars);
+    await configureDlt(coreConfig, envVars);
+    await configureLogging(coreConfig, envVars);
+    await configureBackgroundTask(coreConfig, envVars);
+    await configureTaskScheduler(coreConfig, envVars);
+    await configureEventBus(coreConfig, envVars);
+    await configureTelemetry(coreConfig, envVars);
+    await configureMessaging(coreConfig, envVars);
+    await configureFaucet(coreConfig, envVars);
+    await configureWallet(coreConfig, envVars);
+    await configureNft(coreConfig, envVars);
+    await configureVerifiableStorage(coreConfig, envVars);
+    await configureIdentity(coreConfig, envVars);
+    await configureIdentityResolver(coreConfig, envVars);
+    await configureIdentityProfile(coreConfig, envVars);
+    await configureAttestation(coreConfig, envVars);
+    await configureDataProcessing(coreConfig, envVars);
+    await configureAuditableItemGraph(coreConfig, envVars);
+    await configureAuditableItemStream(coreConfig, envVars);
+    await configureDocumentManagement(coreConfig, envVars);
+    await configureVerifiableCredentialAuthentication(coreConfig, envVars);
+    await configureRightsManagement(coreConfig, envVars);
+    await configureSynchronisedStorage(coreConfig, envVars);
+    await configureFederatedCatalogue(coreConfig, envVars);
+    await configureDataSpaceConnector(coreConfig, envVars);
     return coreConfig;
 }
-/**
- * Helper function to get IOTA configuration from centralized dltConfig.
- * @param coreConfig The core config.
- * @returns The IOTA configuration if found, undefined otherwise.
- */
-function getIotaConfig(coreConfig) {
-    const dltConfig = coreConfig.types.dltConfig?.find(config => config.type === engineTypes.DltConfigType.Iota && config.isDefault);
-    return dltConfig?.options?.config;
-}
 /**
  * Configures the entity storage.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureEntityStorage(coreConfig, envVars) {
+async function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
     coreConfig.types.entityStorageConnector ??= [];
     const entityStorageConnectorTypes = envVars.entityStorageConnectorType?.split(",") ?? [];
@@ -602,9 +702,10 @@ function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     region: envVars.awsDynamodbRegion ?? "",
-                    accessKeyId: envVars.awsDynamodbAccessKeyId ?? "",
-                    secretAccessKey: envVars.awsDynamodbSecretAccessKey ?? "",
-                    endpoint: envVars.awsDynamodbEndpoint ?? ""
+                    authMode: envVars.awsDynamodbAuthMode,
+                    accessKeyId: envVars.awsDynamodbAccessKeyId,
+                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
+                    endpoint: envVars.awsDynamodbEndpoint
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -683,7 +784,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (entityStorageConnectorTypes) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.PostgreSql)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.PostgreSql,
             options: {
@@ -698,10 +799,19 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
+    const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.Synchronised)) {
+        // For synchronised storage we use the default connector as the one we wrap for real DB operations
+        coreConfig.types.entityStorageConnector.push({
+            type: engineTypes.EntityStorageConnectorType.Synchronised,
+            options: {
+                entityStorageConnectorType: defaultEntityStorageConnectorType
+            }
+        });
+    }
     if (core.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;
             }
@@ -713,7 +823,7 @@ function configureEntityStorage(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureBlobStorage(coreConfig, envVars) {
+async function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
     const blobStorageConnectorTypes = envVars.blobStorageConnectorType?.split(",") ?? [];
     if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.Memory)) {
@@ -752,9 +862,10 @@ function configureBlobStorage(coreConfig, envVars) {
                 config: {
                     region: envVars.awsS3Region ?? "",
                     bucketName: envVars.awsS3BucketName ?? "",
-                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
-                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
-                    endpoint: envVars.awsS3Endpoint ?? ""
+                    authMode: envVars.awsS3AuthMode,
+                    accessKeyId: envVars.awsS3AccessKeyId,
+                    secretAccessKey: envVars.awsS3SecretAccessKey,
+                    endpoint: envVars.awsS3Endpoint
                 },
                 storagePrefix: envVars.blobStoragePrefix
             }
@@ -793,6 +904,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 (core.Is.stringValue(envVars.blobStorageConnectorPublic) &&
+                config.type === envVars.blobStorageConnectorPublic) {
+                config.features ??= [];
+                config.features.push("public");
                 break;
             }
         }
@@ -804,7 +922,7 @@ function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? envVars.blobStorageEncryptionKey
+                        ? (envVars.blobStorageEncryptionKeyId ?? BLOB_STORAGE_ENCRYPTION_KEY_ID)
                         : undefined
                 }
             }
@@ -816,41 +934,43 @@ function configureBlobStorage(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureLogging(coreConfig, envVars) {
+async function configureLogging(coreConfig, envVars) {
     coreConfig.types.loggingConnector ??= [];
-    const loggingConnectors = (envVars.loggingConnector ?? "").split(",");
-    for (const loggingConnector of loggingConnectors) {
+    const loggingConnectorTypes = (envVars.loggingConnector ?? "").split(",");
+    let additionalConnectorCount = 0;
+    for (const loggingConnector of loggingConnectorTypes) {
         if (loggingConnector === engineTypes.LoggingConnectorType.Console) {
-            coreConfig.types.loggingConnector?.push({
+            coreConfig.types.loggingConnector.push({
                 type: engineTypes.LoggingConnectorType.Console,
                 options: {
                     config: {
                         translateMessages: true,
                         hideGroups: true
                     }
-                },
-                isDefault: loggingConnectors.length === 1
+                }
             });
+            additionalConnectorCount++;
         }
         else if (loggingConnector === engineTypes.LoggingConnectorType.EntityStorage) {
-            coreConfig.types.loggingConnector?.push({
-                type: engineTypes.LoggingConnectorType.EntityStorage,
-                isDefault: loggingConnectors.length === 1
+            coreConfig.types.loggingConnector.push({
+                type: engineTypes.LoggingConnectorType.EntityStorage
             });
+            additionalConnectorCount++;
         }
     }
-    if (loggingConnectors.length > 1) {
+    if (additionalConnectorCount > 1) {
         coreConfig.types.loggingConnector?.push({
             type: engineTypes.LoggingConnectorType.Multi,
-            isDefault: true,
             options: {
-                loggingConnectorTypes: loggingConnectors
+                loggingConnectorTypes
             }
         });
     }
-    if (loggingConnectors.length > 0) {
+    if (additionalConnectorCount > 0) {
         coreConfig.types.loggingComponent ??= [];
-        coreConfig.types.loggingComponent.push({ type: engineTypes.LoggingComponentType.Service });
+        // We set the isDefault flag so that other components will get this service by default
+        // and not the generic one from the engine core
+        coreConfig.types.loggingComponent.push({ type: engineTypes.LoggingComponentType.Service, isDefault: true });
     }
 }
 /**
@@ -858,7 +978,7 @@ function configureLogging(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureVault(coreConfig, envVars) {
+async function configureVault(coreConfig, envVars) {
     coreConfig.types.vaultConnector ??= [];
     if (envVars.vaultConnector === engineTypes.VaultConnectorType.EntityStorage) {
         coreConfig.types.vaultConnector.push({
@@ -882,7 +1002,7 @@ function configureVault(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureBackgroundTask(coreConfig, envVars) {
+async function configureBackgroundTask(coreConfig, envVars) {
     coreConfig.types.backgroundTaskConnector ??= [];
     if (envVars.backgroundTaskConnector === engineTypes.BackgroundTaskConnectorType.EntityStorage) {
         coreConfig.types.backgroundTaskConnector.push({
@@ -895,7 +1015,7 @@ function configureBackgroundTask(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureEventBus(coreConfig, envVars) {
+async function configureEventBus(coreConfig, envVars) {
     coreConfig.types.eventBusConnector ??= [];
     if (envVars.eventBusConnector === engineTypes.EventBusConnectorType.Local) {
         coreConfig.types.eventBusConnector.push({
@@ -912,7 +1032,7 @@ function configureEventBus(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureTelemetry(coreConfig, envVars) {
+async function configureTelemetry(coreConfig, envVars) {
     coreConfig.types.telemetryConnector ??= [];
     if (envVars.telemetryConnector === engineTypes.TelemetryConnectorType.EntityStorage) {
         coreConfig.types.telemetryConnector.push({
@@ -929,71 +1049,84 @@ function configureTelemetry(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureMessaging(coreConfig, envVars) {
-    coreConfig.types.messagingEmailConnector ??= [];
-    coreConfig.types.messagingSmsConnector ??= [];
-    coreConfig.types.messagingPushNotificationConnector ??= [];
-    if (envVars.messagingEmailConnector === engineTypes.MessagingEmailConnectorType.EntityStorage) {
-        coreConfig.types.messagingEmailConnector.push({
-            type: engineTypes.MessagingEmailConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.messagingEmailConnector === engineTypes.MessagingEmailConnectorType.Aws) {
-        coreConfig.types.messagingEmailConnector.push({
-            type: engineTypes.MessagingEmailConnectorType.Aws,
-            options: {
-                config: {
-                    region: envVars.awsS3Region ?? "",
-                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
-                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
-                    endpoint: envVars.awsS3Endpoint ?? ""
+async function configureMessaging(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.messagingEnabled) ?? false) {
+        coreConfig.types.messagingEmailConnector ??= [];
+        coreConfig.types.messagingSmsConnector ??= [];
+        coreConfig.types.messagingPushNotificationConnector ??= [];
+        if (envVars.messagingEmailConnector === engineTypes.MessagingEmailConnectorType.EntityStorage) {
+            coreConfig.types.messagingEmailConnector.push({
+                type: engineTypes.MessagingEmailConnectorType.EntityStorage
+            });
+        }
+        else if (envVars.messagingEmailConnector === engineTypes.MessagingEmailConnectorType.Aws) {
+            coreConfig.types.messagingEmailConnector.push({
+                type: engineTypes.MessagingEmailConnectorType.Aws,
+                options: {
+                    config: {
+                        region: envVars.awsSesRegion ?? "",
+                        authMode: envVars.awsSesAuthMode,
+                        accessKeyId: envVars.awsSesAccessKeyId,
+                        secretAccessKey: envVars.awsSesSecretAccessKey,
+                        endpoint: envVars.awsSesEndpoint
+                    }
                 }
-            }
-        });
-    }
-    if (envVars.messagingSmsConnector === engineTypes.MessagingSmsConnectorType.EntityStorage) {
-        coreConfig.types.messagingSmsConnector.push({
-            type: engineTypes.MessagingSmsConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.messagingSmsConnector === engineTypes.MessagingSmsConnectorType.Aws) {
-        coreConfig.types.messagingSmsConnector.push({
-            type: engineTypes.MessagingSmsConnectorType.Aws,
-            options: {
-                config: {
-                    region: envVars.awsS3Region ?? "",
-                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
-                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
-                    endpoint: envVars.awsS3Endpoint ?? ""
+            });
+        }
+        if (envVars.messagingSmsConnector === engineTypes.MessagingSmsConnectorType.EntityStorage) {
+            coreConfig.types.messagingSmsConnector.push({
+                type: engineTypes.MessagingSmsConnectorType.EntityStorage
+            });
+        }
+        else if (envVars.messagingSmsConnector === engineTypes.MessagingSmsConnectorType.Aws) {
+            coreConfig.types.messagingSmsConnector.push({
+                type: engineTypes.MessagingSmsConnectorType.Aws,
+                options: {
+                    config: {
+                        region: envVars.awsSesRegion ?? "",
+                        authMode: envVars.awsSesAuthMode,
+                        accessKeyId: envVars.awsSesAccessKeyId,
+                        secretAccessKey: envVars.awsSesSecretAccessKey,
+                        endpoint: envVars.awsSesEndpoint
+                    }
                 }
-            }
-        });
-    }
-    if (envVars.messagingPushNotificationConnector ===
-        engineTypes.MessagingPushNotificationConnectorType.EntityStorage) {
-        coreConfig.types.messagingPushNotificationConnector.push({
-            type: engineTypes.MessagingPushNotificationConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.messagingPushNotificationConnector === engineTypes.MessagingPushNotificationConnectorType.Aws) {
-        coreConfig.types.messagingPushNotificationConnector.push({
-            type: engineTypes.MessagingPushNotificationConnectorType.Aws,
+            });
+        }
+        if (envVars.messagingPushNotificationConnector ===
+            engineTypes.MessagingPushNotificationConnectorType.EntityStorage) {
+            coreConfig.types.messagingPushNotificationConnector.push({
+                type: engineTypes.MessagingPushNotificationConnectorType.EntityStorage
+            });
+        }
+        else if (envVars.messagingPushNotificationConnector === engineTypes.MessagingPushNotificationConnectorType.Aws) {
+            coreConfig.types.messagingPushNotificationConnector.push({
+                type: engineTypes.MessagingPushNotificationConnectorType.Aws,
+                options: {
+                    config: {
+                        region: envVars.awsSesRegion ?? "",
+                        authMode: envVars.awsSesAuthMode,
+                        accessKeyId: envVars.awsSesAccessKeyId,
+                        secretAccessKey: envVars.awsSesSecretAccessKey,
+                        endpoint: envVars.awsSesEndpoint,
+                        applicationsSettings: core.Is.json(envVars.awsMessagingPushNotificationApplications)
+                            ? JSON.parse(envVars.awsMessagingPushNotificationApplications)
+                            : []
+                    }
+                }
+            });
+        }
+        const templates = core.Is.arrayValue(envVars.messagingTemplates)
+            ? envVars.messagingTemplates
+            : undefined;
+        coreConfig.types.messagingAdminComponent ??= [];
+        coreConfig.types.messagingAdminComponent.push({
+            type: engineTypes.MessagingAdminComponentType.Service,
             options: {
                 config: {
-                    region: envVars.awsS3Region ?? "",
-                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
-                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
-                    endpoint: envVars.awsS3Endpoint ?? "",
-                    applicationsSettings: core.Is.json(envVars.awsMessagingPushNotificationApplications)
-                        ? JSON.parse(envVars.awsMessagingPushNotificationApplications)
-                        : []
+                    templates
                 }
             }
         });
-    }
-    if (coreConfig.types.messagingEmailConnector.length > 0 ||
-        coreConfig.types.messagingSmsConnector.length > 0 ||
-        coreConfig.types.messagingPushNotificationConnector.length > 0) {
         coreConfig.types.messagingComponent ??= [];
         coreConfig.types.messagingComponent.push({ type: engineTypes.MessagingComponentType.Service });
     }
@@ -1003,7 +1136,7 @@ function configureMessaging(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureFaucet(coreConfig, envVars) {
+async function configureFaucet(coreConfig, envVars) {
     coreConfig.types.faucetConnector ??= [];
     if (envVars.faucetConnector === engineTypes.FaucetConnectorType.EntityStorage) {
         coreConfig.types.faucetConnector.push({
@@ -1011,14 +1144,14 @@ function configureFaucet(coreConfig, envVars) {
         });
     }
     else if (envVars.faucetConnector === engineTypes.FaucetConnectorType.Iota) {
-        const iotaConfig = getIotaConfig(coreConfig);
+        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
         coreConfig.types.faucetConnector.push({
             type: engineTypes.FaucetConnectorType.Iota,
             options: {
                 config: {
                     endpoint: envVars.iotaFaucetEndpoint ?? "",
-                    clientOptions: iotaConfig?.clientOptions ?? { url: "" },
-                    network: iotaConfig?.network ?? ""
+                    clientOptions: dltConfig?.options?.config?.clientOptions ?? { url: "" },
+                    network: dltConfig?.options?.config?.network ?? ""
                 }
             }
         });
@@ -1029,7 +1162,7 @@ function configureFaucet(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureWallet(coreConfig, envVars) {
+async function configureWallet(coreConfig, envVars) {
     coreConfig.types.walletConnector ??= [];
     if (envVars.walletConnector === engineTypes.WalletConnectorType.EntityStorage) {
         coreConfig.types.walletConnector.push({
@@ -1037,11 +1170,11 @@ function configureWallet(coreConfig, envVars) {
         });
     }
     else if (envVars.walletConnector === engineTypes.WalletConnectorType.Iota) {
-        const iotaConfig = getIotaConfig(coreConfig);
+        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
         coreConfig.types.walletConnector.push({
             type: engineTypes.WalletConnectorType.Iota,
             options: {
-                config: iotaConfig ?? {}
+                config: dltConfig?.options?.config ?? {}
             }
         });
     }
@@ -1051,7 +1184,7 @@ function configureWallet(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureNft(coreConfig, envVars) {
+async function configureNft(coreConfig, envVars) {
     coreConfig.types.nftConnector ??= [];
     if (envVars.nftConnector === engineTypes.NftConnectorType.EntityStorage) {
         coreConfig.types.nftConnector.push({
@@ -1059,11 +1192,11 @@ function configureNft(coreConfig, envVars) {
         });
     }
     else if (envVars.nftConnector === engineTypes.NftConnectorType.Iota) {
-        const iotaConfig = getIotaConfig(coreConfig);
+        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
         coreConfig.types.nftConnector.push({
             type: engineTypes.NftConnectorType.Iota,
             options: {
-                config: iotaConfig ?? {}
+                config: dltConfig?.options?.config ?? {}
             }
         });
     }
@@ -1077,7 +1210,7 @@ function configureNft(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureVerifiableStorage(coreConfig, envVars) {
+async function configureVerifiableStorage(coreConfig, envVars) {
     coreConfig.types.verifiableStorageConnector ??= [];
     if (envVars.verifiableStorageConnector === engineTypes.VerifiableStorageConnectorType.EntityStorage) {
         coreConfig.types.verifiableStorageConnector.push({
@@ -1085,11 +1218,11 @@ function configureVerifiableStorage(coreConfig, envVars) {
         });
     }
     else if (envVars.verifiableStorageConnector === engineTypes.VerifiableStorageConnectorType.Iota) {
-        const iotaConfig = getIotaConfig(coreConfig);
+        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
         coreConfig.types.verifiableStorageConnector.push({
             type: engineTypes.VerifiableStorageConnectorType.Iota,
             options: {
-                config: iotaConfig ?? {}
+                config: dltConfig?.options?.config ?? {}
             }
         });
     }
@@ -1103,18 +1236,10 @@ function configureVerifiableStorage(coreConfig, envVars) {
             type: engineTypes.ImmutableProofComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.immutableProofVerificationMethodId
+                    verificationMethodId: envVars.immutableProofVerificationMethodId ?? IMMUTABLE_PROOF_VERIFICATION_METHOD_ID
                 }
             }
         });
-        coreConfig.types.auditableItemGraphComponent ??= [];
-        coreConfig.types.auditableItemGraphComponent.push({
-            type: engineTypes.AuditableItemGraphComponentType.Service
-        });
-        coreConfig.types.auditableItemStreamComponent ??= [];
-        coreConfig.types.auditableItemStreamComponent.push({
-            type: engineTypes.AuditableItemStreamComponentType.Service
-        });
     }
 }
 /**
@@ -1122,7 +1247,7 @@ function configureVerifiableStorage(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureIdentity(coreConfig, envVars) {
+async function configureIdentity(coreConfig, envVars) {
     coreConfig.types.identityConnector ??= [];
     if (envVars.identityConnector === engineTypes.IdentityConnectorType.EntityStorage) {
         coreConfig.types.identityConnector.push({
@@ -1130,11 +1255,11 @@ function configureIdentity(coreConfig, envVars) {
         });
     }
     else if (envVars.identityConnector === engineTypes.IdentityConnectorType.Iota) {
-        const iotaConfig = getIotaConfig(coreConfig);
+        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
         coreConfig.types.identityConnector.push({
             type: engineTypes.IdentityConnectorType.Iota,
             options: {
-                config: iotaConfig ?? {}
+                config: dltConfig?.options?.config ?? {}
             }
         });
     }
@@ -1148,7 +1273,7 @@ function configureIdentity(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureIdentityResolver(coreConfig, envVars) {
+async function configureIdentityResolver(coreConfig, envVars) {
     coreConfig.types.identityResolverConnector ??= [];
     if (envVars.identityResolverConnector === engineTypes.IdentityResolverConnectorType.EntityStorage) {
         coreConfig.types.identityResolverConnector.push({
@@ -1156,11 +1281,11 @@ function configureIdentityResolver(coreConfig, envVars) {
         });
     }
     else if (envVars.identityResolverConnector === engineTypes.IdentityResolverConnectorType.Iota) {
-        const iotaConfig = getIotaConfig(coreConfig);
+        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
         coreConfig.types.identityResolverConnector.push({
             type: engineTypes.IdentityResolverConnectorType.Iota,
             options: {
-                config: iotaConfig ?? {}
+                config: dltConfig?.options?.config ?? {}
             }
         });
     }
@@ -1186,7 +1311,7 @@ function configureIdentityResolver(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureIdentityProfile(coreConfig, envVars) {
+async function configureIdentityProfile(coreConfig, envVars) {
     coreConfig.types.identityProfileConnector ??= [];
     if (envVars.identityProfileConnector === engineTypes.IdentityConnectorType.EntityStorage) {
         coreConfig.types.identityProfileConnector.push({
@@ -1203,7 +1328,7 @@ function configureIdentityProfile(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureAttestation(coreConfig, envVars) {
+async function configureAttestation(coreConfig, envVars) {
     coreConfig.types.attestationConnector ??= [];
     if (envVars.attestationConnector === engineTypes.AttestationConnectorType.Nft) {
         coreConfig.types.attestationConnector.push({
@@ -1216,7 +1341,7 @@ function configureAttestation(coreConfig, envVars) {
             type: engineTypes.AttestationComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.attestationVerificationMethodId
+                    verificationMethodId: envVars.attestationVerificationMethodId ?? ATTESTATION_VERIFICATION_METHOD_ID
                 }
             }
         });
@@ -1227,8 +1352,8 @@ function configureAttestation(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureAuditableItemGraph(coreConfig, envVars) {
-    if (core.Is.arrayValue(coreConfig.types.verifiableStorageConnector)) {
+async function configureAuditableItemGraph(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.auditableItemGraphEnabled) ?? false) {
         coreConfig.types.auditableItemGraphComponent ??= [];
         coreConfig.types.auditableItemGraphComponent.push({
             type: engineTypes.AuditableItemGraphComponentType.Service
@@ -1240,8 +1365,8 @@ function configureAuditableItemGraph(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureAuditableItemStream(coreConfig, envVars) {
-    if (core.Is.arrayValue(coreConfig.types.verifiableStorageConnector)) {
+async function configureAuditableItemStream(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.auditableItemStreamEnabled) ?? false) {
         coreConfig.types.auditableItemStreamComponent ??= [];
         coreConfig.types.auditableItemStreamComponent.push({
             type: engineTypes.AuditableItemStreamComponentType.Service
@@ -1253,34 +1378,33 @@ function configureAuditableItemStream(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureDataProcessing(coreConfig, envVars) {
-    coreConfig.types.dataConverterConnector ??= [];
-    coreConfig.types.dataExtractorConnector ??= [];
-    const converterConnectors = envVars.dataConverterConnectors?.split(",") ?? [];
-    for (const converterConnector of converterConnectors) {
-        if (converterConnector === engineTypes.DataConverterConnectorType.Json) {
-            coreConfig.types.dataConverterConnector.push({
-                type: engineTypes.DataConverterConnectorType.Json
-            });
-        }
-        else if (converterConnector === engineTypes.DataConverterConnectorType.Xml) {
-            coreConfig.types.dataConverterConnector.push({
-                type: engineTypes.DataConverterConnectorType.Xml
-            });
-        }
-    }
-    const extractorConnectors = envVars.dataExtractorConnectors?.split(",") ?? [];
-    for (const extractorConnector of extractorConnectors) {
-        if (extractorConnector === engineTypes.DataExtractorConnectorType.JsonPath) {
-            coreConfig.types.dataExtractorConnector.push({
-                type: engineTypes.DataExtractorConnectorType.JsonPath
-            });
-        }
-    }
-    if (coreConfig.types.dataConverterConnector.length > 0 ||
-        coreConfig.types.dataExtractorConnector.length > 0) {
+async function configureDataProcessing(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.dataProcessingEnabled) ?? false) {
         coreConfig.types.dataProcessingComponent ??= [];
         coreConfig.types.dataProcessingComponent.push({ type: engineTypes.DataProcessingComponentType.Service });
+        coreConfig.types.dataConverterConnector ??= [];
+        const converterConnectors = envVars.dataConverterConnectors?.split(",") ?? [];
+        for (const converterConnector of converterConnectors) {
+            if (converterConnector === engineTypes.DataConverterConnectorType.Json) {
+                coreConfig.types.dataConverterConnector.push({
+                    type: engineTypes.DataConverterConnectorType.Json
+                });
+            }
+            else if (converterConnector === engineTypes.DataConverterConnectorType.Xml) {
+                coreConfig.types.dataConverterConnector.push({
+                    type: engineTypes.DataConverterConnectorType.Xml
+                });
+            }
+        }
+        coreConfig.types.dataExtractorConnector ??= [];
+        const extractorConnectors = envVars.dataExtractorConnectors?.split(",") ?? [];
+        for (const extractorConnector of extractorConnectors) {
+            if (extractorConnector === engineTypes.DataExtractorConnectorType.JsonPath) {
+                coreConfig.types.dataExtractorConnector.push({
+                    type: engineTypes.DataExtractorConnectorType.JsonPath
+                });
+            }
+        }
     }
 }
 /**
@@ -1288,10 +1412,8 @@ function configureDataProcessing(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureDocumentManagement(coreConfig, envVars) {
-    if (core.Is.arrayValue(coreConfig.types.auditableItemGraphComponent) &&
-        core.Is.arrayValue(coreConfig.types.blobStorageComponent) &&
-        core.Is.arrayValue(coreConfig.types.attestationComponent)) {
+async function configureDocumentManagement(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.documentManagementEnabled) ?? false) {
         coreConfig.types.documentManagementComponent ??= [];
         coreConfig.types.documentManagementComponent.push({
             type: engineTypes.DocumentManagementComponentType.Service
@@ -1299,21 +1421,22 @@ function configureDocumentManagement(coreConfig, envVars) {
     }
 }
 /**
- * Configures the federated catalogue.
+ * Configures the verifiable credential authentication.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureFederatedCatalogue(coreConfig, envVars) {
-    if (core.Is.arrayValue(coreConfig.types.identityResolverComponent)) {
-        coreConfig.types.federatedCatalogueComponent ??= [];
-        coreConfig.types.federatedCatalogueComponent.push({
-            type: engineTypes.FederatedCatalogueComponentType.Service,
+async function configureVerifiableCredentialAuthentication(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
+        // Can only perform VC authentication if identity component is available
+        coreConfig.types.authenticationGeneratorComponent ??= [];
+        coreConfig.types.authenticationGeneratorComponent.push({
+            type: engineTypes.AuthenticationGeneratorComponentType.VerifiableCredential,
             options: {
                 config: {
-                    subResourceCacheTtlMs: core.Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: core.Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                    verificationMethodId: envVars.vcAuthenticationVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID
                 }
-            }
+            },
+            features: ["verifiable-credential"]
         });
     }
 }
@@ -1322,15 +1445,87 @@ function configureFederatedCatalogue(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureRightsManagement(coreConfig, envVars) {
+async function configureRightsManagement(coreConfig, envVars) {
     if (core.Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
         coreConfig.types.rightsManagementPapComponent ??= [];
         coreConfig.types.rightsManagementPapComponent.push({
             type: engineTypes.RightsManagementPapComponentType.Service
         });
-        coreConfig.types.rightsManagementComponent ??= [];
-        coreConfig.types.rightsManagementComponent.push({
-            type: engineTypes.RightsManagementComponentType.Service
+        coreConfig.types.rightsManagementPmpComponent ??= [];
+        coreConfig.types.rightsManagementPmpComponent.push({
+            type: engineTypes.RightsManagementPmpComponentType.Service
+        });
+        coreConfig.types.rightsManagementPipComponent ??= [];
+        coreConfig.types.rightsManagementPipComponent.push({
+            type: engineTypes.RightsManagementPipComponentType.Service,
+            options: {
+                informationModulesConfig: core.Is.arrayValue(envVars.rightsManagementInformationSources)
+                    ? envVars.rightsManagementInformationSources
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPxpComponent ??= [];
+        coreConfig.types.rightsManagementPxpComponent.push({
+            type: engineTypes.RightsManagementPxpComponentType.Service,
+            options: {
+                actionModulesConfig: core.Is.arrayValue(envVars.rightsManagementExecutionActions)
+                    ? envVars.rightsManagementExecutionActions
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPdpComponent ??= [];
+        coreConfig.types.rightsManagementPdpComponent.push({
+            type: engineTypes.RightsManagementPdpComponentType.Service,
+            options: {
+                arbiterModulesConfig: core.Is.arrayValue(envVars.rightsManagementArbiters)
+                    ? envVars.rightsManagementArbiters
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPepComponent ??= [];
+        coreConfig.types.rightsManagementPepComponent.push({
+            type: engineTypes.RightsManagementPepComponentType.Service,
+            options: {
+                processorModulesConfig: core.Is.arrayValue(envVars.rightsManagementEnforcementProcessors)
+                    ? envVars.rightsManagementEnforcementProcessors
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPnpComponent ??= [];
+        coreConfig.types.rightsManagementPnpComponent.push({
+            type: engineTypes.RightsManagementPnpComponentType.Service,
+            options: {
+                negotiatorModulesConfig: core.Is.arrayValue(envVars.rightsManagementNegotiators)
+                    ? envVars.rightsManagementNegotiators
+                    : undefined,
+                requesterModulesConfig: core.Is.arrayValue(envVars.rightsManagementRequesters)
+                    ? envVars.rightsManagementRequesters
+                    : undefined,
+                config: {
+                    baseCallbackUrl: envVars.rightsManagementBaseCallbackUrl ?? "",
+                    offers: core.Is.arrayValue(envVars.rightsManagementOffers)
+                        ? envVars.rightsManagementOffers
+                        : [],
+                    negotiationComponentCreator: async (url) => new rightsManagementRestClient.PolicyNegotiationPointClient({ endpoint: url })
+                }
+            }
+        });
+        coreConfig.types.rightsManagementPnapComponent ??= [];
+        coreConfig.types.rightsManagementPnapComponent.push({
+            type: engineTypes.RightsManagementPnapComponentType.Service
+        });
+        coreConfig.types.rightsManagementDapComponent ??= [];
+        coreConfig.types.rightsManagementDapComponent.push({
+            type: engineTypes.RightsManagementDapComponentType.Service
+        });
+        coreConfig.types.rightsManagementDarpComponent ??= [];
+        coreConfig.types.rightsManagementDarpComponent.push({
+            type: engineTypes.RightsManagementDarpComponentType.Service,
+            options: {
+                config: {
+                    dataAccessComponentCreator: async (url) => new rightsManagementRestClient.DataAccessPointClient({ endpoint: url })
+                }
+            }
         });
     }
 }
@@ -1339,11 +1534,92 @@ function configureRightsManagement(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureTaskScheduler(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.taskSchedulerEnabled) ?? true) {
+async function configureTaskScheduler(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
         coreConfig.types.taskSchedulerComponent ??= [];
         coreConfig.types.taskSchedulerComponent.push({
-            type: engineTypes.TaskSchedulerComponentType.Default
+            type: engineTypes.TaskSchedulerComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the synchronised storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureSynchronisedStorage(coreConfig, envVars) {
+    if (core.Is.arrayValue(coreConfig.types.identityResolverComponent) &&
+        (core.Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false)) {
+        // Check if the config provides a custom verifiable storage key id
+        let verifiableStorageKeyId = core.Coerce.string(envVars.synchronisedStorageVerifiableStorageKeyId);
+        if (!core.Is.stringValue(verifiableStorageKeyId)) {
+            // No custom key so default to the network setting
+            verifiableStorageKeyId = envVars.iotaNetwork;
+        }
+        coreConfig.types.synchronisedStorageComponent ??= [];
+        coreConfig.types.synchronisedStorageComponent.push({
+            type: engineTypes.SynchronisedStorageComponentType.Service,
+            options: {
+                config: {
+                    verifiableStorageKeyId: verifiableStorageKeyId ?? "",
+                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId ??
+                        SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID,
+                    entityUpdateIntervalMinutes: core.Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
+                    consolidationIntervalMinutes: core.Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
+                    consolidationBatchSize: core.Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
+                    maxConsolidations: core.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 (core.Is.stringValue(envVars.synchronisedStorageTrustedUrl)) {
+            coreConfig.types.synchronisedStorageComponent.push({
+                type: engineTypes.SynchronisedStorageComponentType.RestClient,
+                options: {
+                    endpoint: envVars.synchronisedStorageTrustedUrl
+                },
+                features: ["trusted"]
+            });
+        }
+    }
+}
+/**
+ * Configures the federated catalogue.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureFederatedCatalogue(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) {
+        coreConfig.types.federatedCatalogueComponent ??= [];
+        coreConfig.types.federatedCatalogueComponent.push({
+            type: engineTypes.FederatedCatalogueComponentType.Service,
+            options: {
+                config: {
+                    subResourceCacheTtlMs: core.Coerce.number(envVars.federatedCatalogueCacheTtlMs),
+                    clearingHouseApproverList: core.Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the data space connector.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureDataSpaceConnector(coreConfig, envVars) {
+    if (core.Coerce.boolean(envVars.dataSpaceConnectorEnabled) ?? false) {
+        coreConfig.types.dataSpaceConnectorComponent ??= [];
+        coreConfig.types.dataSpaceConnectorComponent.push({
+            type: engineTypes.DataSpaceConnectorComponentType.Service,
+            options: {
+                config: {
+                    retainActivityLogsFor: core.Coerce.number(envVars.dataSpaceConnectorRetainActivityLogsFor),
+                    activityLogsCleanUpInterval: core.Coerce.number(envVars.dataSpaceConnectorActivityLogsCleanUpInterval)
+                }
+            }
         });
     }
 }
@@ -1352,7 +1628,7 @@ function configureTaskScheduler(coreConfig, envVars) {
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureDlt(coreConfig, envVars) {
+async function configureDlt(coreConfig, envVars) {
     // Create centralized DLT configuration for IOTA if essential IOTA variables are set
     if (core.Is.stringValue(envVars.iotaNodeEndpoint) && core.Is.stringValue(envVars.iotaNetwork)) {
         coreConfig.types.dltConfig ??= [];
@@ -1386,10 +1662,10 @@ function configureDlt(coreConfig, envVars) {
  * @param coreEngineConfig The core engine config.
  * @param serverInfo The server information.
  * @param openApiSpecPath The path to the open api spec.
- * @returns The the config for the core and the server.
+ * @param favIconPath The path to the favicon.
+ * @returns The config for the core and the server.
  */
-function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath) {
-    envVars.authSigningKeyId ??= "auth-signing";
+async function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath, favIconPath) {
     const webServerOptions = {
         port: core.Coerce.number(envVars.port),
         host: core.Coerce.string(envVars.host),
@@ -1415,7 +1691,8 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
                     options: {
                         config: {
                             serverInfo,
-                            openApiSpecPath
+                            openApiSpecPath,
+                            favIconPath
                         }
                     }
                 }
@@ -1435,8 +1712,9 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
     }
     serverConfig.types.restRouteProcessor ??= [];
     serverConfig.types.socketRouteProcessor ??= [];
-    const disableNodeIdentity = core.Coerce.boolean(envVars.disableNodeIdentity);
-    if (!disableNodeIdentity) {
+    const features = getFeatures(envVars);
+    const hasNodeIdentity = features.includes(NodeFeatures.NodeIdentity);
+    if (hasNodeIdentity) {
         serverConfig.types.restRouteProcessor.push({
             type: engineServerTypes.RestRouteProcessorType.NodeIdentity
         });
@@ -1445,11 +1723,18 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
         });
     }
     if (!coreEngineConfig.silent) {
+        const includeBody = core.Coerce.boolean(envVars.routeLoggingIncludeBody) ?? coreEngineConfig.debug;
+        const fullBase64 = core.Coerce.boolean(envVars.routeLoggingFullBase64) ?? false;
+        const obfuscateProperties = core.Is.stringValue(envVars.routeLoggingObfuscateProperties)
+            ? envVars.routeLoggingObfuscateProperties.split(",")
+            : undefined;
         serverConfig.types.restRouteProcessor.push({
             type: engineServerTypes.RestRouteProcessorType.Logging,
             options: {
                 config: {
-                    includeBody: coreEngineConfig.debug
+                    includeBody,
+                    fullBase64,
+                    obfuscateProperties
                 }
             }
         });
@@ -1457,7 +1742,9 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
             type: engineServerTypes.SocketRouteProcessorType.Logging,
             options: {
                 config: {
-                    includeBody: coreEngineConfig.debug
+                    includeBody,
+                    fullBase64,
+                    obfuscateProperties
                 }
             }
         });
@@ -1495,7 +1782,7 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
             type: engineServerTypes.AuthenticationComponentType.EntityStorage,
             options: {
                 config: {
-                    signingKeyName: envVars.authSigningKeyId
+                    signingKeyName: envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID
                 }
             }
         });
@@ -1503,7 +1790,7 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
             type: engineServerTypes.RestRouteProcessorType.AuthHeader,
             options: {
                 config: {
-                    signingKeyName: envVars.authSigningKeyId
+                    signingKeyName: envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID
                 }
             }
         });
@@ -1511,11 +1798,19 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
             type: engineServerTypes.SocketRouteProcessorType.AuthHeader,
             options: {
                 config: {
-                    signingKeyName: envVars.authSigningKeyId
+                    signingKeyName: envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID
                 }
             }
         });
     }
+    if (core.Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
+        serverConfig.types.restRouteProcessor.push({
+            type: engineServerTypes.RestRouteProcessorType.AuthVerifiableCredential
+        });
+        serverConfig.types.socketRouteProcessor.push({
+            type: engineServerTypes.SocketRouteProcessorType.AuthVerifiableCredential
+        });
+    }
     engineServer.addDefaultRestPaths(serverConfig);
     engineServer.addDefaultSocketPaths(serverConfig);
     return serverConfig;
@@ -1523,18 +1818,115 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-console */
+/**
+ * Handles the configuration of the extensions.
+ * @param envVars The environment variables for the node.
+ * @param nodeEngineConfig The node engine config.
+ * @returns The config for the core and the server.
+ */
+async function extensionsConfiguration(envVars, nodeEngineConfig) {
+    if (core.Is.stringValue(envVars.extensions)) {
+        const extensions = envVars.extensions.split(",");
+        for (const extension of extensions) {
+            let initialiseConfigMethod;
+            try {
+                cliCore.CLIDisplay.value(core.I18n.formatMessage("node.extensionLoading"), extension);
+                initialiseConfigMethod = await modules.ModuleHelper.getModuleMethod(extension, "extensionInitialise");
+            }
+            catch (err) {
+                throw new core.GeneralError("node", "extensionLoadingError", { extension }, err);
+            }
+            if (core.Is.function(initialiseConfigMethod)) {
+                await initialiseConfigMethod(envVars, nodeEngineConfig);
+            }
+        }
+    }
+    return nodeEngineConfig;
+}
+/**
+ * Handles the initialisation of the extensions when the engine has been constructed.
+ * @param envVars The environment variables for the node.
+ * @param engineCore The engine core instance.
+ * @returns Nothing.
+ */
+async function extensionsInitialiseEngine(envVars, engineCore) {
+    if (core.Is.stringValue(envVars.extensions)) {
+        const extensions = envVars.extensions.split(",");
+        for (const extension of extensions) {
+            let initialiseEngineMethod;
+            try {
+                engineCore.logInfo(core.I18n.formatMessage("node.extensionInitialisingEngine", { extension }));
+                initialiseEngineMethod =
+                    await modules.ModuleHelper.getModuleMethod(extension, "extensionInitialiseEngine");
+            }
+            catch { }
+            if (core.Is.function(initialiseEngineMethod)) {
+                await initialiseEngineMethod(engineCore);
+            }
+        }
+    }
+}
+/**
+ * Handles the initialisation of the extensions when the engine server has been constructed.
+ * @param envVars The environment variables for the node.
+ * @param engineCore The engine core instance.
+ * @param engineServer The engine server instance.
+ * @returns Nothing.
+ */
+async function extensionsInitialiseEngineServer(envVars, engineCore, engineServer) {
+    if (core.Is.stringValue(envVars.extensions)) {
+        const extensions = envVars.extensions.split(",");
+        for (const extension of extensions) {
+            let initialiseEngineServerMethod;
+            try {
+                engineCore.logInfo(core.I18n.formatMessage("node.extensionInitialisingEngineServer", { extension }));
+                initialiseEngineServerMethod =
+                    await modules.ModuleHelper.getModuleMethod(extension, "extensionInitialiseEngineServer");
+            }
+            catch { }
+            if (core.Is.function(initialiseEngineServerMethod)) {
+                await initialiseEngineServerMethod(engineCore, engineServer);
+            }
+        }
+    }
+}
+/**
+ * Handles the shutdown of the extensions.
+ * @param envVars The environment variables for the node.
+ * @param engineCore The engine core instance.
+ * @returns Nothing.
+ */
+async function shutdownExtensions(envVars, engineCore) {
+    if (core.Is.stringValue(envVars.extensions)) {
+        const extensions = envVars.extensions.split(",");
+        for (const extension of extensions) {
+            let shutdownMethod;
+            try {
+                engineCore.logInfo(core.I18n.formatMessage("node.extensionShutdown", { extension }));
+                shutdownMethod = await modules.ModuleHelper.getModuleMethod(extension, "extensionShutdown");
+            }
+            catch { }
+            if (core.Is.function(shutdownMethod)) {
+                await shutdownMethod();
+            }
+        }
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
  * Start the engine server.
  * @param nodeOptions Optional run options for the engine server.
- * @param engineServerConfig The configuration for the engine server.
+ * @param nodeEngineConfig The configuration for the engine server.
  * @param envVars The environment variables.
  * @returns The engine server.
  */
-async function start(nodeOptions, engineServerConfig, envVars) {
-    envVars.storageFileRoot ??= "";
+async function start(nodeOptions, nodeEngineConfig, envVars) {
     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(engineTypes.EntityStorageConnectorType.File) ||
         blobStorageConnectorType.includes(engineTypes.BlobStorageConnectorType.File) ||
         core.Is.empty(nodeOptions?.stateStorage)) &&
@@ -1543,24 +1935,26 @@ 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$1 = new engine.Engine({
-        config: engineServerConfig,
+        config: nodeEngineConfig,
         stateStorage: nodeOptions?.stateStorage ?? new engineCore.FileStateStorage(envVars.stateFilename ?? ""),
         customBootstrap: async (core, engineContext) => bootstrap(core, engineContext, envVars)
     });
+    // Construct the server with the engine.
+    const server = new engineServer.EngineServer({ engineCore: engine$1 });
     // Extend the engine.
     if (core.Is.function(nodeOptions?.extendEngine)) {
-        console.info("Extending Engine");
+        engine$1.logInfo(core.I18n.formatMessage("node.extendingEngine"));
         await nodeOptions.extendEngine(engine$1);
     }
-    // Construct the server with the engine.
-    const server = new engineServer.EngineServer({ engineCore: engine$1 });
+    await extensionsInitialiseEngine(envVars, engine$1);
     // Extend the engine server.
     if (core.Is.function(nodeOptions?.extendEngineServer)) {
-        console.info("Extending Engine Server");
+        engine$1.logInfo(core.I18n.formatMessage("node.extendingEngineServer"));
         await nodeOptions?.extendEngineServer(server);
     }
+    await extensionsInitialiseEngineServer(envVars, engine$1, server);
     // Need to register the engine with the factory so that background tasks
     // can clone it to spawn new instances.
     engineModels.EngineCoreFactory.register("engine", () => engine$1);
@@ -1569,14 +1963,17 @@ async function start(nodeOptions, engineServerConfig, envVars) {
     if (canContinue) {
         return {
             engine: engine$1,
-            server
+            server,
+            shutdown: async () => {
+                await server.stop();
+                await shutdownExtensions(envVars, engine$1);
+            }
         };
     }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-/* eslint-disable no-console */
 /**
  * Run the TWIN Node server.
  * @param nodeOptions Optional configuration options for running the server.
@@ -1587,41 +1984,60 @@ 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.21" // x-release-please-version
         };
-        console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
+        cliCore.CLIDisplay.header(serverInfo.name, serverInfo.version, "🌩️ ");
         if (!core.Is.stringValue(nodeOptions?.executionDirectory)) {
             nodeOptions.executionDirectory = getExecutionDirectory();
         }
-        console.info("Execution Directory:", nodeOptions.executionDirectory);
+        cliCore.CLIDisplay.value("Execution Directory", nodeOptions.executionDirectory);
         nodeOptions.localesDirectory =
             nodeOptions?.localesDirectory ??
                 path.resolve(path.join(nodeOptions.executionDirectory, "dist", "locales"));
-        console.info("Locales Directory:", nodeOptions.localesDirectory);
+        cliCore.CLIDisplay.value("Locales Directory", nodeOptions.localesDirectory);
         await initialiseLocales(nodeOptions.localesDirectory);
         if (core.Is.empty(nodeOptions?.openApiSpecFile)) {
-            const specFile = path.resolve(path.join(nodeOptions.executionDirectory, "docs", "open-api", "spec.json"));
-            console.info("Default OpenAPI Spec File:", specFile);
+            const specFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "docs", "open-api", "spec.json"));
+            cliCore.CLIDisplay.value("Default OpenAPI Spec File", specFile);
             if (await fileExists(specFile)) {
                 nodeOptions ??= {};
                 nodeOptions.openApiSpecFile = specFile;
             }
         }
+        else {
+            cliCore.CLIDisplay.value("OpenAPI Spec File", nodeOptions.openApiSpecFile);
+        }
+        if (core.Is.empty(nodeOptions?.favIconFile)) {
+            const favIconFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "static", "favicon.png"));
+            cliCore.CLIDisplay.value("Default Favicon File", favIconFile);
+            if (await fileExists(favIconFile)) {
+                nodeOptions ??= {};
+                nodeOptions.favIconFile = favIconFile;
+            }
+        }
+        else {
+            cliCore.CLIDisplay.value("Favicon File", nodeOptions.favIconFile);
+        }
         nodeOptions.envPrefix ??= "TWIN_NODE_";
-        console.info("Environment Prefix:", nodeOptions.envPrefix);
-        const { engineServerConfig, nodeEnvVars: envVars } = await buildConfiguration(process.env, nodeOptions, serverInfo);
-        console.info();
-        const startResult = await start(nodeOptions, engineServerConfig, envVars);
+        cliCore.CLIDisplay.value("Environment Variable Prefix", nodeOptions.envPrefix);
+        overrideModuleImport(nodeOptions.executionDirectory ?? "");
+        const { nodeEngineConfig, nodeEnvVars: envVars } = await buildConfiguration(
+        // This is the only location in the code base that should access process.env directly
+        // eslint-disable-next-line no-restricted-syntax
+        process.env, nodeOptions, serverInfo);
+        cliCore.CLIDisplay.break();
+        const startResult = await start(nodeOptions, nodeEngineConfig, envVars);
         if (!core.Is.empty(startResult)) {
             for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
                 process.on(signal, async () => {
-                    await startResult.server.stop();
+                    cliCore.CLIDisplay.value("Terminate Signal", signal);
+                    await startResult.shutdown();
                 });
             }
         }
     }
     catch (err) {
-        console.error(core.ErrorHelper.formatErrors(err).join("\n"));
+        cliCore.CLIDisplay.error(err);
         // eslint-disable-next-line unicorn/no-process-exit
         process.exit(1);
     }
@@ -1638,14 +2054,15 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     let defaultEnvOnly = false;
     if (core.Is.empty(options?.envFilenames)) {
         const envFile = path.resolve(path.join(options.executionDirectory ?? "", ".env"));
-        console.info("Default Environment File:", envFile);
+        cliCore.CLIDisplay.value("Default Environment File", envFile);
         options ??= {};
         options.envFilenames = [envFile];
         defaultEnvOnly = true;
     }
     if (core.Is.arrayValue(options?.envFilenames)) {
         const output = dotenv__namespace.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.
@@ -1660,58 +2077,114 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     // Expand any environment variables that use the @file: syntax
     const keys = Object.keys(envVars);
     for (const key of keys) {
-        if (core.Is.stringValue(envVars[key]) && envVars[key].startsWith("@file:")) {
+        if (core.Is.stringValue(envVars[key]) &&
+            (envVars[key].startsWith("@text:") || envVars[key].startsWith("@json:"))) {
             const filePath = envVars[key].slice(6).trim();
             const embeddedFile = path.resolve(path.join(options.executionDirectory ?? "", filePath));
-            console.info(`Expanding Environment Variable: ${key} from file: ${embeddedFile}`);
-            const fileContent = await loadJsonFile(embeddedFile);
-            envVars[key] = fileContent;
+            if (envVars[key].startsWith("@text:")) {
+                cliCore.CLIDisplay.value(`Expanding Environment Variable: ${key} from text file`, embeddedFile);
+                envVars[key] = await loadTextFile(embeddedFile);
+            }
+            else if (envVars[key].startsWith("@json:")) {
+                cliCore.CLIDisplay.value(`Expanding Environment Variable: ${key} from JSON file`, embeddedFile);
+                envVars[key] = await loadJsonFile(embeddedFile);
+            }
         }
     }
     // Extend the environment variables with any additional custom configuration.
     if (core.Is.function(options?.extendEnvVars)) {
-        console.info("Extending Environment Variables");
+        cliCore.CLIDisplay.task("Extending Environment Variables");
         await options.extendEnvVars(envVars);
     }
     // Build the engine configuration from the environment variables.
-    const coreConfig = buildEngineConfiguration(envVars);
-    const engineServerConfig = buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile);
+    const coreConfig = await buildEngineConfiguration(envVars);
+    const engineServerConfig = await buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile, options?.favIconFile);
     // Merge any custom configuration provided in the options.
     if (core.Is.arrayValue(options?.configFilenames)) {
         for (const configFile of options.configFilenames) {
-            console.info("Loading Configuration File:", configFile);
+            cliCore.CLIDisplay.value("Loading Configuration File", configFile);
             const configFilePath = path.resolve(path.join(options.executionDirectory ?? "", configFile));
             const config = await loadJsonFile(configFilePath);
             Object.assign(engineServerConfig, config);
         }
     }
     if (core.Is.objectValue(options?.config)) {
-        console.info("Merging Custom Configuration");
+        cliCore.CLIDisplay.task("Merging Custom Configuration");
         Object.assign(engineServerConfig, options.config);
     }
     // Merge any custom configuration provided in the options.
     if (core.Is.function(options?.extendConfig)) {
-        console.info("Extending Configuration");
-        await options.extendConfig(engineServerConfig);
+        cliCore.CLIDisplay.task("Extending Configuration");
+        await options.extendConfig(envVars, engineServerConfig);
     }
-    return { engineServerConfig, nodeEnvVars: envVars };
+    const nodeEngineConfig = await extensionsConfiguration(envVars, engineServerConfig);
+    return { nodeEngineConfig, nodeEnvVars: envVars };
+}
+/**
+ * Override module imports to use local files where possible.
+ * @param executionDirectory The execution directory for resolving local module paths.
+ */
+function overrideModuleImport(executionDirectory) {
+    modules.ModuleHelper.overrideImport(async (moduleName) => {
+        // If the module path for example when dynamically loading
+        // modules looks like a local file then we try to resolve
+        // using the local file system
+        const isLocal = modules.ModuleHelper.isLocalModule(moduleName);
+        if (isLocal) {
+            // See if we can just resolve the filename locally
+            let localFilename = path.resolve(moduleName);
+            let exists = await fileExists(localFilename);
+            if (!exists) {
+                // Doesn't exist in the current directory, try the execution directory
+                localFilename = path.resolve(executionDirectory, moduleName);
+                exists = await fileExists(localFilename);
+            }
+            if (exists) {
+                // If the module exists then we can load it, otherwise
+                // we fallback to regular handling to see if that can import it
+                return {
+                    module: await import(process.platform === "win32" ? `file://${localFilename}` : localFilename),
+                    useDefault: false
+                };
+            }
+        }
+        // The filename doesn't look like a local module, so just use default handling
+        return {
+            useDefault: true
+        };
+    });
 }
 
+exports.ATTESTATION_VERIFICATION_METHOD_ID = ATTESTATION_VERIFICATION_METHOD_ID;
+exports.AUTH_SIGNING_KEY_ID = AUTH_SIGNING_KEY_ID;
+exports.BLOB_STORAGE_ENCRYPTION_KEY_ID = BLOB_STORAGE_ENCRYPTION_KEY_ID;
+exports.IMMUTABLE_PROOF_VERIFICATION_METHOD_ID = IMMUTABLE_PROOF_VERIFICATION_METHOD_ID;
 exports.NodeFeatures = NodeFeatures;
+exports.SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID = SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID;
+exports.VC_AUTHENTICATION_VERIFICATION_METHOD_ID = VC_AUTHENTICATION_VERIFICATION_METHOD_ID;
 exports.bootstrap = bootstrap;
-exports.bootstrapAttestationMethod = bootstrapAttestationMethod;
 exports.bootstrapAuth = bootstrapAuth;
 exports.bootstrapBlobEncryption = bootstrapBlobEncryption;
 exports.bootstrapImmutableProofMethod = bootstrapImmutableProofMethod;
 exports.bootstrapNodeIdentity = bootstrapNodeIdentity;
 exports.bootstrapNodeUser = bootstrapNodeUser;
+exports.bootstrapSynchronisedStorage = bootstrapSynchronisedStorage;
 exports.buildConfiguration = buildConfiguration;
 exports.buildEngineConfiguration = buildEngineConfiguration;
 exports.buildEngineServerConfiguration = buildEngineServerConfiguration;
+exports.directoryExists = directoryExists;
+exports.extensionsConfiguration = extensionsConfiguration;
+exports.extensionsInitialiseEngine = extensionsInitialiseEngine;
+exports.extensionsInitialiseEngineServer = extensionsInitialiseEngineServer;
 exports.fileExists = fileExists;
 exports.getExecutionDirectory = getExecutionDirectory;
 exports.getFeatures = getFeatures;
+exports.getFiles = getFiles;
+exports.getSubFolders = getSubFolders;
 exports.initialiseLocales = initialiseLocales;
 exports.loadJsonFile = loadJsonFile;
+exports.loadTextFile = loadTextFile;
+exports.overrideModuleImport = overrideModuleImport;
 exports.run = run;
+exports.shutdownExtensions = shutdownExtensions;
 exports.start = start;