@twin.org/node-core 0.0.2-next.1 → 0.0.2-next.11

package/dist/esm/index.mjs

@@ -1,15 +1,17 @@
 import { PasswordHelper } from '@twin.org/api-auth-entity-storage-service';
-import { I18n, Is, Converter, RandomHelper, StringHelper, Coerce, Urn, GeneralError, ErrorHelper, EnvHelper } from '@twin.org/core';
+import { I18n, Is, Coerce, Converter, RandomHelper, StringHelper, Urn, GeneralError, ErrorHelper, EnvHelper } from '@twin.org/core';
 import { PasswordGenerator, Bip39 } from '@twin.org/crypto';
-import { WalletConnectorType, IdentityConnectorType, EntityStorageConnectorType, BlobStorageConnectorType, BlobStorageComponentType, VaultConnectorType, DltConfigType, LoggingConnectorType, LoggingComponentType, BackgroundTaskConnectorType, EventBusConnectorType, EventBusComponentType, TelemetryConnectorType, TelemetryComponentType, MessagingEmailConnectorType, MessagingSmsConnectorType, MessagingPushNotificationConnectorType, MessagingComponentType, FaucetConnectorType, NftConnectorType, NftComponentType, VerifiableStorageConnectorType, VerifiableStorageComponentType, ImmutableProofComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, IdentityComponentType, IdentityResolverConnectorType, IdentityResolverComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, AttestationConnectorType, AttestationComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DocumentManagementComponentType, FederatedCatalogueComponentType, RightsManagementPapComponentType, RightsManagementComponentType, TaskSchedulerComponentType } from '@twin.org/engine-types';
+import { AuthenticationComponentType, InformationComponentType, RestRouteProcessorType, SocketRouteProcessorType, AuthenticationAdminComponentType } from '@twin.org/engine-server-types';
+import { WalletConnectorType, IdentityConnectorType, EntityStorageConnectorType, BlobStorageConnectorType, BlobStorageComponentType, VaultConnectorType, DltConfigType, LoggingConnectorType, LoggingComponentType, BackgroundTaskConnectorType, TaskSchedulerComponentType, EventBusConnectorType, EventBusComponentType, TelemetryConnectorType, TelemetryComponentType, MessagingEmailConnectorType, MessagingSmsConnectorType, MessagingPushNotificationConnectorType, MessagingComponentType, FaucetConnectorType, NftConnectorType, NftComponentType, VerifiableStorageConnectorType, VerifiableStorageComponentType, ImmutableProofComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, IdentityComponentType, IdentityResolverConnectorType, IdentityResolverComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, AttestationConnectorType, AttestationComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DocumentManagementComponentType, RightsManagementPapComponentType, RightsManagementPmpComponentType, RightsManagementPipComponentType, RightsManagementPxpComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPnpComponentType, RightsManagementPnapComponentType, RightsManagementPnrpComponentType, SynchronisedStorageComponentType, FederatedCatalogueComponentType, DataSpaceConnectorComponentType } from '@twin.org/engine-types';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { IdentityProfileConnectorFactory, IdentityConnectorFactory, IdentityResolverConnectorFactory, DocumentHelper } from '@twin.org/identity-models';
 import { VaultConnectorFactory, VaultKeyType } from '@twin.org/vault-models';
 import { WalletConnectorFactory } from '@twin.org/wallet-models';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { PolicyNegotiationPointClient } from '@twin.org/rights-management-rest-client';
 import { addDefaultRestPaths, addDefaultSocketPaths, EngineServer } from '@twin.org/engine-server';
-import { InformationComponentType, RestRouteProcessorType, SocketRouteProcessorType, AuthenticationAdminComponentType, AuthenticationComponentType } from '@twin.org/engine-server-types';
+import { ModuleHelper } from '@twin.org/modules';
 import * as dotenv from 'dotenv';
 import { Engine } from '@twin.org/engine';
 import { FileStateStorage } from '@twin.org/engine-core';
@@ -29,7 +31,11 @@ const NodeFeatures = {
     /**
      * NodeUser - generates a user for the node if not provided in config.
      */
-    NodeUser: "node-user"
+    NodeUser: "node-user",
+    /**
+     * NodeWallet - generates a wallet for the node and funds it when there is a faucet available.
+     */
+    NodeWallet: "node-wallet"
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -71,13 +77,21 @@ async function fileExists(filename) {
         return false;
     }
 }
+/**
+ * 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 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 readFile(filename, "utf8");
+    const content = await loadTextFile(filename);
     return JSON.parse(content);
 }
 /**
@@ -116,8 +130,12 @@ async function bootstrap(engineCore, context, envVars) {
     await bootstrapNodeUser(engineCore, context, envVars, features);
     await bootstrapAuth(engineCore, context, envVars);
     await bootstrapBlobEncryption(engineCore, context, envVars);
-    await bootstrapAttestationMethod(engineCore, context, envVars);
-    await bootstrapImmutableProofMethod(engineCore, context, envVars);
+    await addVerificationMethod(engineCore, context, "attestation", envVars.attestationVerificationMethodId);
+    await addVerificationMethod(engineCore, context, "immutable proof", envVars.immutableProofVerificationMethodId);
+    if (Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+        await addVerificationMethod(engineCore, context, "rights management", envVars.rightsManagementNegotiationMethodId);
+    }
+    await bootstrapSynchronisedStorage(engineCore, context, envVars);
 }
 /**
  * Bootstrap the node creating any necessary resources.
@@ -132,23 +150,21 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
         // But we have a chicken and egg problem in that we can't create the identity
         // to store the mnemonic in the vault without an identity. We use a temporary identity
         // and then replace it with the new identity later in the process.
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        if (!Is.empty(engineDefaultTypes.vaultConnector)) {
-            const vaultConnector = VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-            const workingIdentity = envVars.identity ??
-                context.state.nodeIdentity ??
-                `bootstrap-temp-${Converter.bytesToHex(RandomHelper.generate(16))}`;
-            await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
-            const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
-            const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
-            await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
-            await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
-            context.state.nodeIdentity = finalIdentity;
-            context.stateDirty = true;
-            engineCore.logInfo(I18n.formatMessage("node.nodeIdentity", {
-                identity: context.state.nodeIdentity
-            }));
-        }
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
+        const workingIdentity = envVars.identity ??
+            context.state.nodeIdentity ??
+            `bootstrap-temp-${Converter.bytesToHex(RandomHelper.generate(16))}`;
+        await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
+        const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
+        const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
+        await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
+        await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
+        context.state.nodeIdentity = finalIdentity;
+        context.stateDirty = true;
+        engineCore.logInfo(I18n.formatMessage("node.nodeIdentity", {
+            identity: context.state.nodeIdentity
+        }));
     }
 }
 /**
@@ -160,12 +176,13 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
  * @returns The addresses for the wallet.
  */
 async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
+    const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
     // Now create an identity for the node controlled by the address we just funded
-    const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+    const identityConnector = IdentityConnectorFactory.get(defaultIdentityConnectorType);
     let identityDocument;
     try {
-        const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
         identityDocument = await identityResolverConnector.resolveDocument(nodeIdentity);
         engineCore.logInfo(I18n.formatMessage("node.existingNodeIdentity", { identity: nodeIdentity }));
     }
@@ -175,7 +192,7 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
         identityDocument = await identityConnector.createDocument(nodeIdentity);
         engineCore.logInfo(I18n.formatMessage("node.createdNodeIdentity", { identity: identityDocument.id }));
     }
-    if (engineDefaultTypes.identityConnector === IdentityConnectorType.Iota) {
+    if (defaultIdentityConnectorType.startsWith(IdentityConnectorType.Iota)) {
         const didUrn = Urn.fromValidString(identityDocument.id);
         const didParts = didUrn.parts();
         const objectId = didParts[3];
@@ -194,23 +211,26 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
  * @returns The addresses for the wallet.
  */
 async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    const walletConnector = WalletConnectorFactory.get(engineDefaultTypes.walletConnector);
-    const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
-    const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
-    if (balance === 0n) {
-        let address0 = addresses[0];
-        if (engineDefaultTypes.walletConnector === WalletConnectorType.Iota) {
-            address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        const walletConnector = WalletConnectorFactory.get(defaultWalletConnectorType);
+        const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
+        const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
+        if (balance === 0n) {
+            let address0 = addresses[0];
+            if (defaultWalletConnectorType.startsWith(WalletConnectorType.Iota)) {
+                address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+            }
+            engineCore.logInfo(I18n.formatMessage("node.fundingWallet", { address: address0 }));
+            // Add some funds to the wallet from the faucet
+            await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
         }
-        engineCore.logInfo(I18n.formatMessage("node.fundingWallet", { address: address0 }));
-        // Add some funds to the wallet from the faucet
-        await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
-    }
-    else {
-        engineCore.logInfo(I18n.formatMessage("node.fundedWallet"));
+        else {
+            engineCore.logInfo(I18n.formatMessage("node.fundedWallet"));
+        }
+        return addresses;
     }
-    return addresses;
+    return [];
 }
 /**
  * Bootstrap the identity for the node.
@@ -221,15 +241,17 @@ async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
  * @param addresses The addresses for the wallet.
  */
 async function finaliseWallet(engineCore, envVars, features, finalIdentity, addresses) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    // If we are using entity storage for wallet the identity associated with the
-    // address will be wrong, so fix it
-    if (engineDefaultTypes.walletConnector === "entity-storage") {
-        const walletAddress = EntityStorageConnectorFactory.get(StringHelper.kebabCase("WalletAddress"));
-        const addr = await walletAddress.get(addresses[0]);
-        if (!Is.empty(addr)) {
-            addr.identity = finalIdentity;
-            await walletAddress.set(addr);
+    if (features.includes(NodeFeatures.NodeWallet)) {
+        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
+        // If we are using entity storage for wallet the identity associated with the
+        // address will be wrong, so fix it
+        if (defaultWalletConnectorType.startsWith(WalletConnectorType.EntityStorage)) {
+            const walletAddress = EntityStorageConnectorFactory.get(StringHelper.kebabCase("WalletAddress"));
+            const addr = await walletAddress.get(addresses[0]);
+            if (!Is.empty(addr)) {
+                addr.identity = finalIdentity;
+                await walletAddress.set(addr);
+            }
         }
     }
 }
@@ -291,8 +313,8 @@ async function finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity)
  */
 async function bootstrapNodeUser(engineCore, context, envVars, features) {
     if (features.includes(NodeFeatures.NodeUser)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+        const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceType("authenticationComponent");
+        if (defaultAuthenticationComponentType.startsWith(AuthenticationComponentType.EntityStorage) &&
             Is.stringValue(context.state.nodeIdentity)) {
             const authUserEntityStorage = EntityStorageConnectorFactory.get(StringHelper.kebabCase("AuthenticationUser"));
             const email = envVars.username ?? DEFAULT_NODE_USERNAME;
@@ -335,7 +357,8 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
                 }
             }
             // We have create a node user, now we need to create a profile for the user
-            const identityProfileConnector = IdentityProfileConnectorFactory.get(engineDefaultTypes.identityProfileConnector);
+            const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+            const identityProfileConnector = IdentityProfileConnectorFactory.get(defaultIdentityConnectorType);
             if (identityProfileConnector) {
                 let userProfile;
                 try {
@@ -365,43 +388,6 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
         }
     }
 }
-/**
- * Bootstrap the attestation verification methods.
- * @param engineCore The engine core for the node.
- * @param context The context for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- */
-async function bootstrapAttestationMethod(engineCore, context, envVars, features) {
-    if (Is.stringValue(context.state.nodeIdentity) &&
-        Is.arrayValue(context.config.types.identityConnector) &&
-        Is.stringValue(envVars.attestationVerificationMethodId)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
-        const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.attestationVerificationMethodId}`;
-        let createVm = true;
-        try {
-            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            createVm = false;
-        }
-        catch { }
-        if (createVm) {
-            // Add attestation verification method to DID, the correct node context is now in place
-            // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(I18n.formatMessage("node.addingAttestation", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.attestationVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(I18n.formatMessage("node.existingAttestation", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
 /**
  * Bootstrap the immutable proof verification methods.
  * @param engineCore The engine core for the node.
@@ -409,36 +395,7 @@ async function bootstrapAttestationMethod(engineCore, context, envVars, features
  * @param envVars The environment variables for the node.
  * @param features The features that are enabled on the node.
  */
-async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    if (Is.stringValue(context.state.nodeIdentity) &&
-        Is.arrayValue(context.config.types.identityConnector) &&
-        Is.stringValue(envVars.immutableProofVerificationMethodId)) {
-        const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
-        const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`;
-        let createVm = true;
-        try {
-            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            createVm = false;
-        }
-        catch { }
-        if (createVm) {
-            // Add AIG verification method to DID, the correct node context is now in place
-            // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(I18n.formatMessage("node.addingImmutableProof", {
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.immutableProofVerificationMethodId);
-        }
-        else {
-            engineCore.logInfo(I18n.formatMessage("node.existingImmutableProof", {
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
+async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) { }
 /**
  * Bootstrap the keys for blob encryption.
  * @param engineCore The engine core for the node.
@@ -449,18 +406,28 @@ async function bootstrapImmutableProofMethod(engineCore, context, envVars, featu
 async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
     if ((Coerce.boolean(envVars.blobStorageEnableEncryption) ?? false) &&
         Is.stringValue(context.state.nodeIdentity)) {
-        const engineDefaultTypes = engineCore.getDefaultTypes();
         // Create a new key for encrypting blobs
-        const vaultConnector = VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
-        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`;
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
+        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKeyId}`;
         let existingKey;
         try {
             existingKey = await vaultConnector.getKey(keyName);
         }
         catch { }
         if (Is.empty(existingKey)) {
-            engineCore.logInfo(I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
-            await vaultConnector.createKey(keyName, VaultKeyType.ChaCha20Poly1305);
+            if (Is.stringBase64(envVars.blobStorageSymmetricEncryptionKey)) {
+                engineCore.logInfo(I18n.formatMessage("node.addingBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, VaultKeyType.ChaCha20Poly1305, Converter.base64ToBytes(envVars.blobStorageSymmetricEncryptionKey));
+            }
+            else {
+                engineCore.logInfo(I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
+                const key = await vaultConnector.createKey(keyName, VaultKeyType.ChaCha20Poly1305);
+                engineCore.logInfo(I18n.formatMessage("node.createdBlobEncryptionKey", {
+                    keyName,
+                    keyValue: Converter.bytesToBase64(key)
+                }));
+            }
         }
         else {
             engineCore.logInfo(I18n.formatMessage("node.existingBlobEncryptionKey", { keyName }));
@@ -475,11 +442,13 @@ async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
  * @param features The features that are enabled on the node.
  */
 async function bootstrapAuth(engineCore, context, envVars, features) {
-    const engineDefaultTypes = engineCore.getDefaultTypes();
-    if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+    const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceTypeOptional("authenticationComponent");
+    if (Is.stringValue(defaultAuthenticationComponentType) &&
+        defaultAuthenticationComponentType.startsWith(AuthenticationComponentType.EntityStorage) &&
         Is.stringValue(context.state.nodeIdentity)) {
         // Create a new JWT signing key and a user login for the node
-        const vaultConnector = VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
+        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
         const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId}`;
         let existingKey;
         try {
@@ -495,6 +464,76 @@ async function bootstrapAuth(engineCore, context, envVars, features) {
         }
     }
 }
+/**
+ * Bootstrap the synchronised storage blob encryption and verification methods.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapSynchronisedStorage(engineCore, context, envVars, features) {
+    if (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) {
+        // Add the verification method to the identity if it doesn't exist
+        await addVerificationMethod(engineCore, context, "synchronised storage", envVars.synchronisedStorageVerificationMethodId);
+        // If this is a trusted node we need to add the blob encryption key pair
+        if (Is.stringValue(envVars.synchronisedStorageBlobStorageEncryptionKeyId) &&
+            Is.stringBase64(envVars.synchronisedStorageBlobStorageKey)) {
+            const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+            const vaultConnector = VaultConnectorFactory.get(defaultVaultConnectorType);
+            const keyName = envVars.synchronisedStorageBlobStorageEncryptionKeyId;
+            let existingKey;
+            try {
+                existingKey = await vaultConnector.getKey(keyName);
+            }
+            catch { }
+            if (Is.empty(existingKey)) {
+                engineCore.logInfo(I18n.formatMessage("node.addingSynchronisedStorageBlobEncryptionKey", { keyName }));
+                await vaultConnector.addKey(keyName, VaultKeyType.ChaCha20Poly1305, Converter.base64ToBytes(envVars.synchronisedStorageBlobStorageKey));
+            }
+            else {
+                engineCore.logInfo(I18n.formatMessage("node.existingSynchronisedStorageBlobEncryptionKey", { keyName }));
+            }
+        }
+    }
+}
+/**
+ * Add a verification method if it doesn't exist.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param verificationMethodTitle The verification method title.
+ * @param verificationMethodId The verification method ID.
+ */
+async function addVerificationMethod(engineCore, context, verificationMethodTitle, verificationMethodId) {
+    if (Is.stringValue(context.state.nodeIdentity) &&
+        Is.arrayValue(context.config.types.identityConnector) &&
+        Is.stringValue(verificationMethodId)) {
+        const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+        const identityConnector = IdentityConnectorFactory.get(defaultIdentityConnectorType);
+        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
+        const identityResolverConnector = IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
+        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        const fullMethodId = `${identityDocument.id}#${verificationMethodId}`;
+        let exists = false;
+        try {
+            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
+            exists = true;
+        }
+        catch { }
+        if (!exists) {
+            engineCore.logInfo(I18n.formatMessage("node.addingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", verificationMethodId);
+        }
+        else {
+            engineCore.logInfo(I18n.formatMessage("node.existingVerificationMethod", {
+                title: verificationMethodTitle,
+                methodId: fullMethodId
+            }));
+        }
+    }
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -512,7 +551,10 @@ function buildEngineConfiguration(envVars) {
     envVars.attestationVerificationMethodId ??= "attestation-assertion";
     envVars.immutableProofVerificationMethodId ??= "immutable-proof-assertion";
     envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    envVars.blobStorageEncryptionKeyId ??= "blob-encryption";
+    envVars.synchronisedStorageBlobStorageEncryptionKeyId ??= "synchronised-storage-blob-encryption";
+    envVars.synchronisedStorageVerificationMethodId ??= "synchronised-storage-assertion";
+    envVars.rightsManagementNegotiationMethodId ??= "policy-negotiation-assertion";
     const coreConfig = {
         debug: Coerce.boolean(envVars.debug) ?? false,
         types: {}
@@ -523,6 +565,7 @@ function buildEngineConfiguration(envVars) {
     configureDlt(coreConfig, envVars);
     configureLogging(coreConfig, envVars);
     configureBackgroundTask(coreConfig, envVars);
+    configureTaskScheduler(coreConfig, envVars);
     configureEventBus(coreConfig, envVars);
     configureTelemetry(coreConfig, envVars);
     configureMessaging(coreConfig, envVars);
@@ -538,9 +581,10 @@ function buildEngineConfiguration(envVars) {
     configureAuditableItemGraph(coreConfig);
     configureAuditableItemStream(coreConfig);
     configureDocumentManagement(coreConfig);
-    configureFederatedCatalogue(coreConfig, envVars);
     configureRightsManagement(coreConfig, envVars);
-    configureTaskScheduler(coreConfig, envVars);
+    configureSynchronisedStorage(coreConfig, envVars);
+    configureFederatedCatalogue(coreConfig, envVars);
+    configureDataSpaceConnector(coreConfig, envVars);
     return coreConfig;
 }
 /**
@@ -560,14 +604,13 @@ function getIotaConfig(coreConfig) {
 function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
     coreConfig.types.entityStorageConnector ??= [];
-    if ((Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
-        envVars.entityStorageConnectorType === EntityStorageConnectorType.Memory) {
+    const entityStorageConnectorTypes = envVars.entityStorageConnectorType?.split(",") ?? [];
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Memory)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.Memory
         });
     }
-    if ((Coerce.boolean(envVars.entityFileEnable) ?? false) ||
-        envVars.entityStorageConnectorType === EntityStorageConnectorType.File) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.File)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.File,
             options: {
@@ -576,7 +619,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.AwsDynamoDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.AwsDynamoDb,
             options: {
@@ -590,7 +633,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.azureCosmosdbKey)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.AzureCosmosDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.AzureCosmosDb,
             options: {
@@ -604,7 +647,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.gcpFirestoreCredentials)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.GcpFirestoreDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.GcpFirestoreDb,
             options: {
@@ -619,41 +662,27 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.scylladbHosts)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.ScyllaDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.ScyllaDb,
             options: {
                 config: {
-                    hosts: envVars.scylladbHosts.split(",") ?? "",
+                    hosts: envVars.scylladbHosts?.split(",") ?? [],
                     localDataCenter: envVars.scylladbLocalDataCenter ?? "",
-                    keyspace: envVars.scylladbKeyspace ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (Is.stringValue(envVars.mySqlHost)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.MySqlDb,
-            options: {
-                config: {
-                    host: envVars.mySqlHost,
-                    port: envVars.mySqlPort ?? 3306,
-                    user: envVars.mySqlUser ?? "",
-                    password: envVars.mySqlPassword ?? "",
-                    database: envVars.mySqlDatabase ?? ""
+                    keyspace: envVars.scylladbKeyspace ?? "",
+                    port: Coerce.integer(envVars.scylladbPort)
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
         });
     }
-    if (Is.stringValue(envVars.mySqlHost)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.MySqlDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.MySqlDb,
             options: {
                 config: {
-                    host: envVars.mySqlHost,
-                    port: envVars.mySqlPort ?? 3306,
+                    host: envVars.mySqlHost ?? "",
+                    port: Coerce.integer(envVars.mySqlPort),
                     user: envVars.mySqlUser ?? "",
                     password: envVars.mySqlPassword ?? "",
                     database: envVars.mySqlDatabase ?? ""
@@ -662,13 +691,13 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.mongoDbHost)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.MongoDb)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.MongoDb,
             options: {
                 config: {
-                    host: envVars.mongoDbHost,
-                    port: envVars.mongoDbPort,
+                    host: envVars.mongoDbHost ?? "",
+                    port: Coerce.integer(envVars.mongoDbPort),
                     user: envVars.mongoDbUser ?? "",
                     password: envVars.mongoDbPassword ?? "",
                     database: envVars.mongoDbDatabase ?? ""
@@ -677,13 +706,13 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.postgreSqlHost)) {
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.PostgreSql)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.PostgreSql,
             options: {
                 config: {
-                    host: envVars.postgreSqlHost,
-                    port: envVars.postgreSqlPort,
+                    host: envVars.postgreSqlHost ?? "",
+                    port: Coerce.integer(envVars.postgreSqlPort),
                     user: envVars.postgreSqlUser ?? "",
                     password: envVars.postgreSqlPassword ?? "",
                     database: envVars.postgreSqlDatabase ?? ""
@@ -692,11 +721,21 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    const defaultStorageConnector = envVars.entityStorageConnectorType;
-    if (Is.stringValue(defaultStorageConnector)) {
+    const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Synchronised)) {
+        // For synchronised storage we use the default connector as the one we wrap for real DB operations
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.Synchronised,
+            options: {
+                entityStorageConnectorType: defaultEntityStorageConnectorType
+            }
+        });
+    }
+    if (Is.arrayValue(entityStorageConnectorTypes)) {
         for (const config of coreConfig.types.entityStorageConnector) {
-            if (config.type === defaultStorageConnector) {
+            if (config.type === defaultEntityStorageConnectorType) {
                 config.isDefault = true;
+                break;
             }
         }
     }
@@ -708,14 +747,13 @@ function configureEntityStorage(coreConfig, envVars) {
  */
 function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
-    if ((Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
-        envVars.blobStorageConnectorType === BlobStorageConnectorType.Memory) {
+    const blobStorageConnectorTypes = envVars.blobStorageConnectorType?.split(",") ?? [];
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Memory)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.Memory
         });
     }
-    if ((Coerce.boolean(envVars.blobFileEnable) ?? false) ||
-        envVars.blobStorageConnectorType === BlobStorageConnectorType.File) {
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.File)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.File,
             options: {
@@ -728,18 +766,18 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.ipfsApiUrl)) {
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Ipfs)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.Ipfs,
             options: {
                 config: {
-                    apiUrl: envVars.ipfsApiUrl,
+                    apiUrl: envVars.ipfsApiUrl ?? "",
                     bearerToken: envVars.ipfsBearerToken
                 }
             }
         });
     }
-    if (Is.stringValue(envVars.awsS3AccessKeyId)) {
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.AwsS3)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.AwsS3,
             options: {
@@ -754,7 +792,7 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.azureStorageAccountKey)) {
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.AzureStorage)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.AzureStorage,
             options: {
@@ -768,7 +806,7 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    if (Is.stringValue(envVars.gcpStorageCredentials)) {
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.GcpStorage)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.GcpStorage,
             options: {
@@ -782,12 +820,20 @@ function configureBlobStorage(coreConfig, envVars) {
             }
         });
     }
-    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
-    if (Is.stringValue(defaultStorageConnectorType)) {
+    if (Is.arrayValue(blobStorageConnectorTypes)) {
+        const defaultStorageConnectorType = envVars.blobStorageConnectorDefault ?? blobStorageConnectorTypes[0];
         for (const config of coreConfig.types.blobStorageConnector) {
             if (config.type === defaultStorageConnectorType) {
                 config.isDefault = true;
             }
+            // If this blob storage connector is the one to use for public access
+            // then add it as a feature
+            if (Is.stringValue(envVars.blobStorageConnectorPublic) &&
+                config.type === envVars.blobStorageConnectorPublic) {
+                config.features ??= [];
+                config.features.push("public");
+                break;
+            }
         }
     }
     if (coreConfig.types.blobStorageConnector.length > 0) {
@@ -797,7 +843,7 @@ function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? envVars.blobStorageEncryptionKey
+                        ? envVars.blobStorageEncryptionKeyId
                         : undefined
                 }
             }
@@ -1292,51 +1338,168 @@ function configureDocumentManagement(coreConfig, envVars) {
     }
 }
 /**
- * Configures the federated catalogue.
+ * Configures the rights management.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureFederatedCatalogue(coreConfig, envVars) {
-    if (Is.arrayValue(coreConfig.types.identityResolverComponent)) {
-        coreConfig.types.federatedCatalogueComponent ??= [];
-        coreConfig.types.federatedCatalogueComponent.push({
-            type: FederatedCatalogueComponentType.Service,
+function configureRightsManagement(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+        coreConfig.types.rightsManagementPapComponent ??= [];
+        coreConfig.types.rightsManagementPapComponent.push({
+            type: RightsManagementPapComponentType.Service
+        });
+        coreConfig.types.rightsManagementPmpComponent ??= [];
+        coreConfig.types.rightsManagementPmpComponent.push({
+            type: RightsManagementPmpComponentType.Service
+        });
+        coreConfig.types.rightsManagementPipComponent ??= [];
+        coreConfig.types.rightsManagementPipComponent.push({
+            type: RightsManagementPipComponentType.Service,
+            options: {
+                informationModulesConfig: Is.arrayValue(envVars.rightsManagementInformationSources)
+                    ? envVars.rightsManagementInformationSources
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPxpComponent ??= [];
+        coreConfig.types.rightsManagementPxpComponent.push({
+            type: RightsManagementPxpComponentType.Service,
+            options: {
+                actionModulesConfig: Is.arrayValue(envVars.rightsManagementExecutionActions)
+                    ? envVars.rightsManagementExecutionActions
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPdpComponent ??= [];
+        coreConfig.types.rightsManagementPdpComponent.push({
+            type: RightsManagementPdpComponentType.Service
+        });
+        coreConfig.types.rightsManagementPepComponent ??= [];
+        coreConfig.types.rightsManagementPepComponent.push({
+            type: RightsManagementPepComponentType.Service,
+            options: {
+                processorModulesConfig: Is.arrayValue(envVars.rightsManagementEnforcementProcessors)
+                    ? envVars.rightsManagementEnforcementProcessors
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPnpComponent ??= [];
+        coreConfig.types.rightsManagementPnpComponent.push({
+            type: RightsManagementPnpComponentType.Service,
+            options: {
+                negotiatorModulesConfig: Is.arrayValue(envVars.rightsManagementNegotiators)
+                    ? envVars.rightsManagementNegotiators
+                    : undefined
+            }
+        });
+        coreConfig.types.rightsManagementPnapComponent ??= [];
+        coreConfig.types.rightsManagementPnapComponent.push({
+            type: RightsManagementPnapComponentType.Service
+        });
+        coreConfig.types.rightsManagementPnrpComponent ??= [];
+        coreConfig.types.rightsManagementPnrpComponent.push({
+            type: RightsManagementPnrpComponentType.Service,
             options: {
                 config: {
-                    subResourceCacheTtlMs: Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                    negotiationMethodId: envVars.rightsManagementNegotiationMethodId ?? "",
+                    negotiationComponentCreator: async (url) => new PolicyNegotiationPointClient({ endpoint: url })
                 }
             }
         });
     }
 }
 /**
- * Configures the rights management.
+ * Configures the task scheduler.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureRightsManagement(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
-        coreConfig.types.rightsManagementPapComponent ??= [];
-        coreConfig.types.rightsManagementPapComponent.push({
-            type: RightsManagementPapComponentType.Service
+function configureTaskScheduler(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
+        coreConfig.types.taskSchedulerComponent ??= [];
+        coreConfig.types.taskSchedulerComponent.push({
+            type: TaskSchedulerComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the synchronised storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureSynchronisedStorage(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.identityResolverComponent) &&
+        (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false)) {
+        // Check if the config provides a custom verifiable storage key id
+        let verifiableStorageKeyId = Coerce.string(envVars.synchronisedStorageVerifiableStorageKeyId);
+        if (!Is.stringValue(verifiableStorageKeyId)) {
+            // No custom key so default to the network setting
+            verifiableStorageKeyId = envVars.iotaNetwork;
+        }
+        coreConfig.types.synchronisedStorageComponent ??= [];
+        coreConfig.types.synchronisedStorageComponent.push({
+            type: SynchronisedStorageComponentType.Service,
+            options: {
+                config: {
+                    verifiableStorageKeyId: verifiableStorageKeyId ?? "",
+                    synchronisedStorageMethodId: envVars.synchronisedStorageVerificationMethodId,
+                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId,
+                    entityUpdateIntervalMinutes: Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
+                    consolidationIntervalMinutes: Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
+                    consolidationBatchSize: Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
+                    maxConsolidations: Coerce.number(envVars.synchronisedStorageMaxConsolidations)
+                }
+            }
         });
-        coreConfig.types.rightsManagementComponent ??= [];
-        coreConfig.types.rightsManagementComponent.push({
-            type: RightsManagementComponentType.Service
+        // If there is a trusted url set, we need to add a client
+        // and give it a feature of trusted so that when the synchronised
+        // storage is created it can pickup the correct component
+        if (Is.stringValue(envVars.synchronisedStorageTrustedUrl)) {
+            coreConfig.types.synchronisedStorageComponent.push({
+                type: SynchronisedStorageComponentType.RestClient,
+                options: {
+                    endpoint: envVars.synchronisedStorageTrustedUrl
+                },
+                features: ["trusted"]
+            });
+        }
+    }
+}
+/**
+ * Configures the federated catalogue.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFederatedCatalogue(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) {
+        coreConfig.types.federatedCatalogueComponent ??= [];
+        coreConfig.types.federatedCatalogueComponent.push({
+            type: FederatedCatalogueComponentType.Service,
+            options: {
+                config: {
+                    subResourceCacheTtlMs: Coerce.number(envVars.federatedCatalogueCacheTtlMs),
+                    clearingHouseApproverList: Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                }
+            }
         });
     }
 }
 /**
- * Configures the task scheduler.
+ * Configures the data space connector.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-function configureTaskScheduler(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? true) {
-        coreConfig.types.taskSchedulerComponent ??= [];
-        coreConfig.types.taskSchedulerComponent.push({
-            type: TaskSchedulerComponentType.Default
+function configureDataSpaceConnector(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.dataSpaceConnectorEnabled) ?? false) {
+        coreConfig.types.dataSpaceConnectorComponent ??= [];
+        coreConfig.types.dataSpaceConnectorComponent.push({
+            type: DataSpaceConnectorComponentType.Service,
+            options: {
+                config: {
+                    dataSpaceConnectorAppDescriptors: Is.arrayValue(envVars.dataSpaceConnectorApps)
+                        ? envVars.dataSpaceConnectorApps
+                        : undefined
+                }
+            }
         });
     }
 }
@@ -1379,9 +1542,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.
+ * @param favIconPath The path to the favicon.
  * @returns The the config for the core and the server.
  */
-function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath) {
+function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath, favIconPath) {
     envVars.authSigningKeyId ??= "auth-signing";
     const webServerOptions = {
         port: Coerce.number(envVars.port),
@@ -1408,7 +1572,8 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
                     options: {
                         config: {
                             serverInfo,
-                            openApiSpecPath
+                            openApiSpecPath,
+                            favIconPath
                         }
                     }
                 }
@@ -1525,16 +1690,19 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
  * @returns The engine server.
  */
 async function start(nodeOptions, engineServerConfig, envVars) {
-    envVars.storageFileRoot ??= "";
-    if ((envVars.entityStorageConnectorType === EntityStorageConnectorType.File ||
-        envVars.blobStorageConnectorType === BlobStorageConnectorType.File ||
+    const entityStorageConnectorType = envVars.entityStorageConnectorType?.split(",") ?? [];
+    const blobStorageConnectorType = envVars.blobStorageConnectorType?.split(",") ?? [];
+    // If the blob storage or entity storage is configured with file connectors
+    // then we need to make sure the storageFileRoot is set
+    if ((entityStorageConnectorType.includes(EntityStorageConnectorType.File) ||
+        blobStorageConnectorType.includes(BlobStorageConnectorType.File) ||
         Is.empty(nodeOptions?.stateStorage)) &&
         !Is.stringValue(envVars.storageFileRoot)) {
         throw new GeneralError("node", "storageFileRootNotSet", {
             storageFileRoot: `${nodeOptions?.envPrefix ?? ""}_STORAGE_FILE_ROOT`
         });
     }
-    // Create the engine instance using file state storage and custom bootstrap.
+    // Create the engine instance using file state storage unless one is configured in options
     const engine = new Engine({
         config: engineServerConfig,
         stateStorage: nodeOptions?.stateStorage ?? new FileStateStorage(envVars.stateFilename ?? ""),
@@ -1578,7 +1746,7 @@ async function run(nodeOptions) {
         nodeOptions ??= {};
         const serverInfo = {
             name: nodeOptions?.serverName ?? "TWIN Node Server",
-            version: nodeOptions?.serverVersion ?? "0.0.2-next.1" // x-release-please-version
+            version: nodeOptions?.serverVersion ?? "0.0.2-next.11" // x-release-please-version
         };
         console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
         if (!Is.stringValue(nodeOptions?.executionDirectory)) {
@@ -1591,15 +1759,24 @@ async function run(nodeOptions) {
         console.info("Locales Directory:", nodeOptions.localesDirectory);
         await initialiseLocales(nodeOptions.localesDirectory);
         if (Is.empty(nodeOptions?.openApiSpecFile)) {
-            const specFile = path.resolve(path.join(nodeOptions.executionDirectory, "docs", "open-api", "spec.json"));
+            const specFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "docs", "open-api", "spec.json"));
             console.info("Default OpenAPI Spec File:", specFile);
             if (await fileExists(specFile)) {
                 nodeOptions ??= {};
                 nodeOptions.openApiSpecFile = specFile;
             }
         }
+        if (Is.empty(nodeOptions?.favIconFile)) {
+            const favIconFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "static", "favicon.png"));
+            console.info("Default Favicon File:", favIconFile);
+            if (await fileExists(favIconFile)) {
+                nodeOptions ??= {};
+                nodeOptions.favIconFile = favIconFile;
+            }
+        }
         nodeOptions.envPrefix ??= "TWIN_NODE_";
         console.info("Environment Prefix:", nodeOptions.envPrefix);
+        overrideModuleImport(nodeOptions.executionDirectory ?? "");
         const { engineServerConfig, nodeEnvVars: envVars } = await buildConfiguration(process.env, nodeOptions, serverInfo);
         console.info();
         const startResult = await start(nodeOptions, engineServerConfig, envVars);
@@ -1636,7 +1813,8 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     if (Is.arrayValue(options?.envFilenames)) {
         const output = dotenv.config({
-            path: options?.envFilenames
+            path: options?.envFilenames,
+            quiet: true
         });
         // We don't want to throw an error if the default environment file is not found.
         // Only if we have custom environment files.
@@ -1651,12 +1829,18 @@ 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 (Is.stringValue(envVars[key]) && envVars[key].startsWith("@file:")) {
+        if (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:")) {
+                console.info(`Expanding Environment Variable: ${key} from text file: ${embeddedFile}`);
+                envVars[key] = await loadTextFile(embeddedFile);
+            }
+            else if (envVars[key].startsWith("@json:")) {
+                console.info(`Expanding Environment Variable: ${key} from JSON file: ${embeddedFile}`);
+                envVars[key] = await loadJsonFile(embeddedFile);
+            }
         }
     }
     // Extend the environment variables with any additional custom configuration.
@@ -1666,7 +1850,7 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     // Build the engine configuration from the environment variables.
     const coreConfig = buildEngineConfiguration(envVars);
-    const engineServerConfig = buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile);
+    const engineServerConfig = buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile, options?.favIconFile);
     // Merge any custom configuration provided in the options.
     if (Is.arrayValue(options?.configFilenames)) {
         for (const configFile of options.configFilenames) {
@@ -1687,5 +1871,39 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     return { engineServerConfig, nodeEnvVars: envVars };
 }
+/**
+ * Override module imports to use local files where possible.
+ * @param executionDirectory The execution directory for resolving local module paths.
+ */
+function overrideModuleImport(executionDirectory) {
+    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 = 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
+        };
+    });
+}
 
-export { NodeFeatures, bootstrap, bootstrapAttestationMethod, bootstrapAuth, bootstrapBlobEncryption, bootstrapImmutableProofMethod, bootstrapNodeIdentity, bootstrapNodeUser, buildConfiguration, buildEngineConfiguration, buildEngineServerConfiguration, fileExists, getExecutionDirectory, getFeatures, initialiseLocales, loadJsonFile, run, start };
+export { NodeFeatures, bootstrap, bootstrapAuth, bootstrapBlobEncryption, bootstrapImmutableProofMethod, bootstrapNodeIdentity, bootstrapNodeUser, bootstrapSynchronisedStorage, buildConfiguration, buildEngineConfiguration, buildEngineServerConfiguration, fileExists, getExecutionDirectory, getFeatures, initialiseLocales, loadJsonFile, loadTextFile, overrideModuleImport, run, start };