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

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');
@@ -11,7 +12,6 @@ var walletModels = require('@twin.org/wallet-models');
 var promises = require('node:fs/promises');
 var path = require('node:path');
 var engineServer = require('@twin.org/engine-server');
-var engineServerTypes = require('@twin.org/engine-server-types');
 var dotenv = require('dotenv');
 var engine = require('@twin.org/engine');
 var engineCore = require('@twin.org/engine-core');
@@ -50,7 +50,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.
@@ -137,8 +141,9 @@ async function bootstrap(engineCore, context, envVars) {
     await bootstrapNodeUser(engineCore, context, envVars, features);
     await bootstrapAuth(engineCore, context, envVars);
     await bootstrapBlobEncryption(engineCore, context, envVars);
-    await bootstrapAttestationMethod(engineCore, context, envVars);
-    await bootstrapImmutableProofMethod(engineCore, context, envVars);
+    await addVerificationMethod(engineCore, context, "attestation", envVars.attestationVerificationMethodId);
+    await addVerificationMethod(engineCore, context, "immutable proof", envVars.immutableProofVerificationMethodId);
+    await bootstrapSynchronisedStorage(engineCore, context, envVars);
 }
 /**
  * Bootstrap the node creating any necessary resources.
@@ -153,23 +158,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 +184,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 +200,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 +219,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 +249,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 === engineTypes.WalletConnectorType.EntityStorage) {
-        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(core.StringHelper.kebabCase("WalletAddress"));
+            const addr = await walletAddress.get(addresses[0]);
+            if (!core.Is.empty(addr)) {
+                addr.identity = finalIdentity;
+                await walletAddress.set(addr);
+            }
         }
     }
 }
@@ -312,8 +321,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 === "entity-storage-authentication-service" &&
+        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 email = envVars.username ?? DEFAULT_NODE_USERNAME;
@@ -356,7 +365,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 defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
+            const identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(defaultIdentityConnectorType);
             if (identityProfileConnector) {
                 let userProfile;
                 try {
@@ -386,43 +396,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 +403,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 +414,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}`;
         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,11 +450,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 === "entity-storage-authentication-service" &&
+    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 defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
         const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId}`;
         let existingKey;
         try {
@@ -516,6 +472,77 @@ async function bootstrapAuth(engineCore, context, envVars, features) {
         }
     }
 }
+/**
+ * Bootstrap the synchronised storage blob encryption and verification methods.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapSynchronisedStorage(engineCore, context, envVars, features) {
+    if (core.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 (core.Is.stringValue(envVars.synchronisedStorageBlobStorageEncryptionKeyId) &&
+            core.Is.stringBase64(envVars.synchronisedStorageBlobStoragePrivateKey) &&
+            core.Is.stringBase64(envVars.synchronisedStorageBlobStoragePublicKey)) {
+            const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
+            const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
+            const keyName = envVars.synchronisedStorageBlobStorageEncryptionKeyId;
+            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.Rsa2048, core.Converter.base64ToBytes(envVars.synchronisedStorageBlobStoragePrivateKey), core.Converter.base64ToBytes(envVars.synchronisedStorageBlobStoragePublicKey));
+            }
+            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.
@@ -533,7 +560,9 @@ function buildEngineConfiguration(envVars) {
     envVars.attestationVerificationMethodId ??= "attestation-assertion";
     envVars.immutableProofVerificationMethodId ??= "immutable-proof-assertion";
     envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    envVars.blobStorageEncryptionKeyId ??= "blob-encryption";
+    envVars.synchronisedStorageBlobStorageEncryptionKeyId ??= "synchronised-storage-blob-encryption";
+    envVars.synchronisedStorageVerificationMethodId ??= "synchronised-storage-assertion";
     const coreConfig = {
         debug: core.Coerce.boolean(envVars.debug) ?? false,
         types: {}
@@ -559,9 +588,10 @@ function buildEngineConfiguration(envVars) {
     configureAuditableItemGraph(coreConfig);
     configureAuditableItemStream(coreConfig);
     configureDocumentManagement(coreConfig);
-    configureFederatedCatalogue(coreConfig, envVars);
     configureRightsManagement(coreConfig, envVars);
     configureTaskScheduler(coreConfig, envVars);
+    configureSynchronisedStorage(coreConfig, envVars);
+    configureFederatedCatalogue(coreConfig, envVars);
     return coreConfig;
 }
 /**
@@ -683,7 +713,7 @@ function configureEntityStorage(coreConfig, envVars) {
             }
         });
     }
-    if (entityStorageConnectorTypes) {
+    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.PostgreSql)) {
         coreConfig.types.entityStorageConnector.push({
             type: engineTypes.EntityStorageConnectorType.PostgreSql,
             options: {
@@ -698,10 +728,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;
             }
@@ -793,6 +832,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 +850,7 @@ function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? envVars.blobStorageEncryptionKey
+                        ? envVars.blobStorageEncryptionKeyId
                         : undefined
                 }
             }
@@ -1298,25 +1344,6 @@ function configureDocumentManagement(coreConfig, envVars) {
         });
     }
 }
-/**
- * Configures the federated catalogue.
- * @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,
-            options: {
-                config: {
-                    subResourceCacheTtlMs: core.Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: core.Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
-                }
-            }
-        });
-    }
-}
 /**
  * Configures the rights management.
  * @param coreConfig The core config.
@@ -1340,13 +1367,76 @@ function configureRightsManagement(coreConfig, envVars) {
  * @param envVars The environment variables.
  */
 function configureTaskScheduler(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.taskSchedulerEnabled) ?? true) {
+    if (core.Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
         coreConfig.types.taskSchedulerComponent ??= [];
         coreConfig.types.taskSchedulerComponent.push({
             type: engineTypes.TaskSchedulerComponentType.Service
         });
     }
 }
+/**
+ * Configures the synchronised storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+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 ?? "",
+                    synchronisedStorageMethodId: envVars.synchronisedStorageVerificationMethodId,
+                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId,
+                    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.
+ */
+function configureFederatedCatalogue(coreConfig, envVars) {
+    if (core.Is.arrayValue(coreConfig.types.identityResolverComponent) &&
+        (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 DLT.
  * @param coreConfig The core config.
@@ -1532,9 +1622,10 @@ function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, o
  * @returns The engine server.
  */
 async function start(nodeOptions, engineServerConfig, envVars) {
-    envVars.storageFileRoot ??= "";
     const entityStorageConnectorType = envVars.entityStorageConnectorType?.split(",") ?? [];
     const blobStorageConnectorType = envVars.blobStorageConnectorType?.split(",") ?? [];
+    // If the blob storage or entity storage is configured with file connectors
+    // then we need to make sure the storageFileRoot is set
     if ((entityStorageConnectorType.includes(engineTypes.EntityStorageConnectorType.File) ||
         blobStorageConnectorType.includes(engineTypes.BlobStorageConnectorType.File) ||
         core.Is.empty(nodeOptions?.stateStorage)) &&
@@ -1543,7 +1634,7 @@ async function start(nodeOptions, engineServerConfig, envVars) {
             storageFileRoot: `${nodeOptions?.envPrefix ?? ""}_STORAGE_FILE_ROOT`
         });
     }
-    // Create the engine instance using file state storage and custom bootstrap.
+    // Create the engine instance using file state storage unless one is configured in options
     const engine$1 = new engine.Engine({
         config: engineServerConfig,
         stateStorage: nodeOptions?.stateStorage ?? new engineCore.FileStateStorage(envVars.stateFilename ?? ""),
@@ -1587,7 +1678,7 @@ async function run(nodeOptions) {
         nodeOptions ??= {};
         const serverInfo = {
             name: nodeOptions?.serverName ?? "TWIN Node Server",
-            version: nodeOptions?.serverVersion ?? "0.0.2-next.3" // x-release-please-version
+            version: nodeOptions?.serverVersion ?? "0.0.2-next.4" // x-release-please-version
         };
         console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
         if (!core.Is.stringValue(nodeOptions?.executionDirectory)) {
@@ -1645,7 +1736,8 @@ async function buildConfiguration(processEnv, options, serverInfo) {
     }
     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.
@@ -1699,12 +1791,12 @@ async function buildConfiguration(processEnv, options, serverInfo) {
 
 exports.NodeFeatures = NodeFeatures;
 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;