@twin.org/node-core 0.0.2-next.25 → 0.0.2-next.27

package/dist/cjs/index.cjs

@@ -1,2232 +0,0 @@
-'use strict';
-
-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');
-var vaultModels = require('@twin.org/vault-models');
-var walletModels = require('@twin.org/wallet-models');
-var promises = require('node:fs/promises');
-var path = require('node:path');
-var cliCore = require('@twin.org/cli-core');
-var rightsManagementRestClient = require('@twin.org/rights-management-rest-client');
-var engineServer = require('@twin.org/engine-server');
-var modules = require('@twin.org/modules');
-var node_child_process = require('node:child_process');
-var dotenv = require('dotenv');
-var engine = require('@twin.org/engine');
-var engineCore = require('@twin.org/engine-core');
-var engineModels = require('@twin.org/engine-models');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var dotenv__namespace = /*#__PURE__*/_interopNamespaceDefault(dotenv);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-const ATTESTATION_VERIFICATION_METHOD_ID = "attestation-assertion";
-const IMMUTABLE_PROOF_VERIFICATION_METHOD_ID = "immutable-proof-assertion";
-const BLOB_STORAGE_ENCRYPTION_KEY_ID = "blob-encryption";
-const SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID = "synchronised-storage-blob-encryption";
-const VC_AUTHENTICATION_VERIFICATION_METHOD_ID = "node-authentication-assertion";
-const AUTH_SIGNING_KEY_ID = "auth-signing";
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * The features that can be enabled on the node.
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-const NodeFeatures = {
-    /**
-     * NodeIdentity - generates an identity for the node if not provided in config.
-     */
-    NodeIdentity: "node-identity",
-    /**
-     * NodeUser - generates a user for the node if not provided in config.
-     */
-    NodeUser: "node-user",
-    /**
-     * NodeWallet - generates a wallet for the node and funds it when there is a faucet available.
-     */
-    NodeWallet: "node-wallet"
-};
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the locales for the application.
- * @param localesDirectory The directory containing the locales.
- */
-async function initialiseLocales(localesDirectory) {
-    const localesFile = path.resolve(path.join(localesDirectory, "en.json"));
-    cliCore.CLIDisplay.value("Locales File", localesFile);
-    if (await fileExists(localesFile)) {
-        const enLangContent = await promises.readFile(localesFile, "utf8");
-        core.I18n.addDictionary("en", JSON.parse(enLangContent));
-    }
-    else {
-        cliCore.CLIDisplay.error(`Locales file not found: ${localesFile}`);
-    }
-}
-/**
- * Get the directory where the application is being executed.
- * @returns The execution directory.
- */
-function getExecutionDirectory() {
-    return process.cwd();
-}
-/**
- * Does the specified file exist.
- * @param filename The filename to check for existence.
- * @returns True if the file exists.
- */
-async function fileExists(filename) {
-    try {
-        const stats = await promises.stat(filename);
-        return stats.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Does the specified directory exist.
- * @param directory The directory to check for existence.
- * @returns True if the directory exists.
- */
-async function directoryExists(directory) {
-    try {
-        const stats = await promises.stat(directory);
-        return stats.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the sub folders for the folder.
- * @param directory The directory to get the sub folders.
- * @returns The list of sub folders.
- */
-async function getSubFolders(directory) {
-    try {
-        const dir = await promises.readdir(directory);
-        const folders = [];
-        for (const dirEntry of dir) {
-            const fullPath = path.join(directory, dirEntry);
-            const stats = await promises.stat(fullPath);
-            if (stats.isDirectory()) {
-                folders.push(fullPath);
-            }
-        }
-        return folders;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Get the files in the directory.
- * @param directory The directory to get the files from.
- * @returns The list of files in the directory.
- */
-async function getFiles(directory) {
-    try {
-        const dir = await promises.readdir(directory);
-        const files = [];
-        for (const dirEntry of dir) {
-            const fullPath = path.join(directory, dirEntry);
-            const stats = await promises.stat(fullPath);
-            if (stats.isFile()) {
-                files.push(fullPath);
-            }
-        }
-        return files;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Load the text file.
- * @param filename The filename of the text file to load.
- * @returns The contents of the text file if it could not be loaded.
- */
-async function loadTextFile(filename) {
-    return promises.readFile(filename, "utf8");
-}
-/**
- * Load the JSON file.
- * @param filename The filename of the JSON file to load.
- * @returns The contents of the JSON file or null if it could not be loaded.
- */
-async function loadJsonFile(filename) {
-    const content = await loadTextFile(filename);
-    return JSON.parse(content);
-}
-/**
- * Get the features that are enabled on the node.
- * @param env The environment variables for the node.
- * @returns The features that are enabled on the node.
- */
-function getFeatures(env) {
-    if (core.Is.empty(env.features)) {
-        return [];
-    }
-    const features = [];
-    const allFeatures = Object.values(NodeFeatures);
-    const splitFeatures = env.features.split(",");
-    for (const feature of splitFeatures) {
-        const featureTrimmed = feature.trim();
-        if (allFeatures.includes(featureTrimmed)) {
-            features.push(featureTrimmed);
-        }
-    }
-    return features;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-const DEFAULT_NODE_USERNAME = "admin@node";
-/**
- * Bootstrap the application.
- * @param engineCore The engine core for the node.
- * @param context The context for the node.
- * @param envVars The environment variables for the node.
- */
-async function bootstrap(engineCore, context, envVars) {
-    const features = getFeatures(envVars);
-    await bootstrapNodeIdentity(engineCore, context, envVars, features);
-    await bootstrapNodeUser(engineCore, context, envVars, features);
-    await bootstrapAuth(engineCore, context, envVars);
-    await bootstrapBlobEncryption(engineCore, context, envVars);
-    const defaultAttestationConnectorType = engineCore.getRegisteredInstanceTypeOptional("attestationConnector");
-    if (!core.Is.empty(defaultAttestationConnectorType)) {
-        await addVerificationMethod(engineCore, context, "attestation", envVars.attestationVerificationMethodId ?? ATTESTATION_VERIFICATION_METHOD_ID);
-    }
-    const defaultImmutableProofComponentType = engineCore.getRegisteredInstanceTypeOptional("immutableProofComponent");
-    if (!core.Is.empty(defaultImmutableProofComponentType)) {
-        await addVerificationMethod(engineCore, context, "immutable proof", envVars.immutableProofVerificationMethodId ?? IMMUTABLE_PROOF_VERIFICATION_METHOD_ID);
-    }
-    if (core.Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
-        await addVerificationMethod(engineCore, context, "verifiable credential authentication", envVars.vcAuthenticationVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID);
-    }
-    await bootstrapSynchronisedStorage(engineCore, context, envVars);
-}
-/**
- * Bootstrap the node creating any necessary resources.
- * @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. The features that are enabled on the node.
- */
-async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
-    if (features.includes(NodeFeatures.NodeIdentity)) {
-        // When we bootstrap the node we need to generate an identity for it,
-        // 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 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
-        }));
-    }
-}
-/**
- * Bootstrap the identity for the node.
- * @param engineCore The engine core for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node. The features that are enabled on the node.
- * @param nodeIdentity The identity of the node.
- * @returns The addresses for the wallet.
- */
-async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
-    const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
-    // Now create an identity for the node controlled by the address we just funded
-    const identityConnector = identityModels.IdentityConnectorFactory.get(defaultIdentityConnectorType);
-    let identityDocument;
-    try {
-        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 }));
-    }
-    catch { }
-    if (core.Is.empty(identityDocument)) {
-        engineCore.logInfo(core.I18n.formatMessage("node.generatingNodeIdentity"));
-        identityDocument = await identityConnector.createDocument(nodeIdentity);
-        engineCore.logInfo(core.I18n.formatMessage("node.createdNodeIdentity", { identity: identityDocument.id }));
-    }
-    if (defaultIdentityConnectorType.startsWith(engineTypes.IdentityConnectorType.Iota)) {
-        const didUrn = core.Urn.fromValidString(identityDocument.id);
-        const didParts = didUrn.parts();
-        const objectId = didParts[3];
-        engineCore.logInfo(core.I18n.formatMessage("node.identityExplorer", {
-            url: `${envVars.iotaExplorerEndpoint}object/${objectId}?network=${envVars.iotaNetwork}`
-        }));
-    }
-    return identityDocument.id;
-}
-/**
- * Bootstrap the wallet for the node.
- * @param engineCore The engine core for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- * @param nodeIdentity The identity of the node.
- * @returns The addresses for the wallet.
- */
-async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
-    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);
-        }
-        else {
-            engineCore.logInfo(core.I18n.formatMessage("node.fundedWallet"));
-        }
-        return addresses;
-    }
-    return [];
-}
-/**
- * Bootstrap the identity for the node.
- * @param engineCore The engine core for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- * @param finalIdentity The identity of the node.
- * @param addresses The addresses for the wallet.
- */
-async function finaliseWallet(engineCore, envVars, features, finalIdentity, addresses) {
-    if (features.includes(NodeFeatures.NodeWallet)) {
-        const defaultWalletConnectorType = engineCore.getRegisteredInstanceType("walletConnector");
-        // If we are using entity storage for wallet the identity associated with the
-        // address will be wrong, so fix it
-        if (defaultWalletConnectorType.startsWith(engineTypes.WalletConnectorType.EntityStorage)) {
-            const walletAddress = entityStorageModels.EntityStorageConnectorFactory.get("wallet-address");
-            const addr = await walletAddress.get(addresses[0]);
-            if (!core.Is.empty(addr)) {
-                addr.identity = finalIdentity;
-                await walletAddress.set(addr);
-            }
-        }
-    }
-}
-/**
- * Generate a mnemonic for the node identity.
- * @param engineCore The engine core for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- * @param vaultConnector The vault connector to use.
- * @param nodeIdentity The identity of the node.
- */
-async function bootstrapMnemonic(engineCore, envVars, features, vaultConnector, nodeIdentity) {
-    let mnemonic = envVars.mnemonic;
-    let storeMnemonic = false;
-    try {
-        const storedMnemonic = await vaultConnector.getSecret(`${nodeIdentity}/mnemonic`);
-        storeMnemonic = storedMnemonic !== mnemonic;
-        mnemonic = storedMnemonic;
-    }
-    catch {
-        storeMnemonic = true;
-    }
-    // If there is no mnemonic then we need to generate one
-    if (core.Is.empty(mnemonic)) {
-        mnemonic = crypto.Bip39.randomMnemonic();
-        storeMnemonic = true;
-        engineCore.logInfo(core.I18n.formatMessage("node.generatingMnemonic", { mnemonic }));
-    }
-    // If there is no mnemonic stored in the vault then we need to store it
-    if (storeMnemonic) {
-        engineCore.logInfo(core.I18n.formatMessage("node.storingMnemonic"));
-        await vaultConnector.setSecret(`${nodeIdentity}/mnemonic`, mnemonic);
-    }
-    else {
-        engineCore.logInfo(core.I18n.formatMessage("node.existingMnemonic"));
-    }
-}
-/**
- * Finalise the mnemonic for the node identity.
- * @param vaultConnector The vault connector to use.
- * @param workingIdentity The identity of the node.
- * @param finalIdentity The final identity for the node.
- */
-async function finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity) {
-    // Now that we have an identity we can remove the temporary one
-    // and store the mnemonic with the new identity
-    if (workingIdentity.startsWith("bootstrap-temp-") && workingIdentity !== finalIdentity) {
-        const mnemonic = await vaultConnector.getSecret(`${workingIdentity}/mnemonic`);
-        await vaultConnector.setSecret(`${finalIdentity}/mnemonic`, mnemonic);
-        await vaultConnector.removeSecret(`${workingIdentity}/mnemonic`);
-    }
-}
-/**
- * Bootstrap the user.
- * @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 bootstrapNodeUser(engineCore, context, envVars, features) {
-    if (features.includes(NodeFeatures.NodeUser)) {
-        const defaultAuthenticationComponentType = engineCore.getRegisteredInstanceType("authenticationComponent");
-        if (defaultAuthenticationComponentType.startsWith(engineServerTypes.AuthenticationComponentType.EntityStorage) &&
-            core.Is.stringValue(context.state.nodeIdentity)) {
-            const authUserEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get("authentication-user");
-            const email = envVars.username ?? DEFAULT_NODE_USERNAME;
-            let nodeAdminUser = await authUserEntityStorage.get(email);
-            if (core.Is.empty(nodeAdminUser)) {
-                engineCore.logInfo(core.I18n.formatMessage("node.creatingNodeUser", { email }));
-                const generatedPassword = envVars.password ?? crypto.PasswordGenerator.generate(16);
-                const passwordBytes = core.Converter.utf8ToBytes(generatedPassword);
-                const saltBytes = core.RandomHelper.generate(16);
-                const hashedPassword = await apiAuthEntityStorageService.PasswordHelper.hashPassword(passwordBytes, saltBytes);
-                nodeAdminUser = {
-                    email,
-                    password: hashedPassword,
-                    salt: core.Converter.bytesToBase64(saltBytes),
-                    identity: context.state.nodeIdentity
-                };
-                engineCore.logInfo(core.I18n.formatMessage("node.nodeAdminUserEmail", { email: nodeAdminUser.email }));
-                engineCore.logInfo(core.I18n.formatMessage("node.nodeAdminUserPassword", { password: generatedPassword }));
-                await authUserEntityStorage.set(nodeAdminUser);
-            }
-            else {
-                engineCore.logInfo(core.I18n.formatMessage("node.existingNodeUser", { email }));
-                // The user already exists, so double check the other details match
-                let needsUpdate = false;
-                if (nodeAdminUser.identity !== context.state.nodeIdentity) {
-                    nodeAdminUser.identity = context.state.nodeIdentity;
-                    needsUpdate = true;
-                }
-                if (core.Is.stringValue(envVars.password)) {
-                    const passwordBytes = core.Converter.utf8ToBytes(envVars.password);
-                    const saltBytes = core.Converter.base64ToBytes(nodeAdminUser.salt);
-                    const hashedPassword = await apiAuthEntityStorageService.PasswordHelper.hashPassword(passwordBytes, saltBytes);
-                    if (nodeAdminUser.password !== hashedPassword) {
-                        nodeAdminUser.password = hashedPassword;
-                        needsUpdate = true;
-                    }
-                }
-                if (needsUpdate) {
-                    await authUserEntityStorage.set(nodeAdminUser);
-                }
-            }
-            // We have create a node user, now we need to create a profile for the user
-            const defaultIdentityProfileConnectorType = engineCore.getRegisteredInstanceType("identityProfileConnector");
-            const identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(defaultIdentityProfileConnectorType);
-            if (identityProfileConnector) {
-                let userProfile;
-                try {
-                    userProfile = await identityProfileConnector.get(context.state.nodeIdentity);
-                }
-                catch { }
-                if (core.Is.empty(userProfile)) {
-                    engineCore.logInfo(core.I18n.formatMessage("node.creatingUserProfile", { identity: context.state.nodeIdentity }));
-                    const publicProfile = {
-                        "@context": "https://schema.org",
-                        "@type": "Person",
-                        name: "Node Administrator"
-                    };
-                    const privateProfile = {
-                        "@context": "https://schema.org",
-                        "@type": "Person",
-                        givenName: "Node",
-                        familyName: "Administrator",
-                        email
-                    };
-                    await identityProfileConnector.create(context.state.nodeIdentity, publicProfile, privateProfile);
-                }
-                else {
-                    engineCore.logInfo(core.I18n.formatMessage("node.existingUserProfile", { identity: context.state.nodeIdentity }));
-                }
-            }
-        }
-    }
-}
-/**
- * Bootstrap the immutable proof 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 bootstrapImmutableProofMethod(engineCore, context, envVars, features) { }
-/**
- * Bootstrap the keys for blob encryption.
- * @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 bootstrapBlobEncryption(engineCore, context, envVars, features) {
-    if ((core.Coerce.boolean(envVars.blobStorageEnableEncryption) ?? false) &&
-        core.Is.stringValue(context.state.nodeIdentity)) {
-        // Create a new key for encrypting blobs
-        const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
-        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
-        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKeyId ?? BLOB_STORAGE_ENCRYPTION_KEY_ID}`;
-        let existingKey;
-        try {
-            existingKey = await vaultConnector.getKey(keyName);
-        }
-        catch { }
-        if (core.Is.empty(existingKey)) {
-            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 }));
-        }
-    }
-}
-/**
- * Bootstrap the JWT signing key.
- * @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 bootstrapAuth(engineCore, context, envVars, features) {
-    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 defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
-        const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
-        const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID}`;
-        let existingKey;
-        try {
-            existingKey = await vaultConnector.getKey(keyName);
-        }
-        catch { }
-        if (core.Is.empty(existingKey)) {
-            engineCore.logInfo(core.I18n.formatMessage("node.creatingAuthKey", { keyName }));
-            await vaultConnector.createKey(keyName, vaultModels.VaultKeyType.Ed25519);
-        }
-        else {
-            engineCore.logInfo(core.I18n.formatMessage("node.existingAuthKey", { keyName }));
-        }
-    }
-}
-/**
- * Bootstrap the synchronised storage blob encryption and verification methods.
- * @param engineCore The engine core for the node.
- * @param context The context for the node.
- * @param envVars The environment variables for the node.
- * @param features The features that are enabled on the node.
- */
-async function bootstrapSynchronisedStorage(engineCore, context, envVars, features) {
-    if (core.Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) {
-        // If this is a trusted node we need to add the blob encryption key pair
-        if (core.Is.stringBase64(envVars.synchronisedStorageBlobStorageKey)) {
-            const defaultVaultConnectorType = engineCore.getRegisteredInstanceType("vaultConnector");
-            const vaultConnector = vaultModels.VaultConnectorFactory.get(defaultVaultConnectorType);
-            const keyName = envVars.synchronisedStorageBlobStorageEncryptionKeyId ??
-                SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID;
-            let existingKey;
-            try {
-                existingKey = await vaultConnector.getKey(keyName);
-            }
-            catch { }
-            if (core.Is.empty(existingKey)) {
-                engineCore.logInfo(core.I18n.formatMessage("node.addingSynchronisedStorageBlobEncryptionKey", { keyName }));
-                await vaultConnector.addKey(keyName, vaultModels.VaultKeyType.ChaCha20Poly1305, core.Converter.base64ToBytes(envVars.synchronisedStorageBlobStorageKey));
-            }
-            else {
-                engineCore.logInfo(core.I18n.formatMessage("node.existingSynchronisedStorageBlobEncryptionKey", { keyName }));
-            }
-        }
-    }
-}
-/**
- * Add a verification method if it doesn't exist.
- * @param engineCore The engine core for the node.
- * @param context The context for the node.
- * @param verificationMethodTitle The verification method title.
- * @param verificationMethodId The verification method ID.
- */
-async function addVerificationMethod(engineCore, context, verificationMethodTitle, verificationMethodId) {
-    if (core.Is.stringValue(context.state.nodeIdentity) &&
-        core.Is.arrayValue(context.config.types.identityConnector) &&
-        core.Is.stringValue(verificationMethodId)) {
-        const defaultIdentityConnectorType = engineCore.getRegisteredInstanceType("identityConnector");
-        const identityConnector = identityModels.IdentityConnectorFactory.get(defaultIdentityConnectorType);
-        const defaultIdentityResolverConnectorType = engineCore.getRegisteredInstanceType("identityResolverConnector");
-        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(defaultIdentityResolverConnectorType);
-        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
-        const fullMethodId = `${identityDocument.id}#${verificationMethodId}`;
-        let exists = false;
-        try {
-            identityModels.DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
-            exists = true;
-        }
-        catch { }
-        if (!exists) {
-            engineCore.logInfo(core.I18n.formatMessage("node.addingVerificationMethod", {
-                title: verificationMethodTitle,
-                methodId: fullMethodId
-            }));
-            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", verificationMethodId);
-        }
-        else {
-            engineCore.logInfo(core.I18n.formatMessage("node.existingVerificationMethod", {
-                title: verificationMethodTitle,
-                methodId: fullMethodId
-            }));
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Build the engine core configuration from environment variables.
- * @param envVars The environment variables.
- * @returns The config for the core.
- */
-async function buildEngineConfiguration(envVars) {
-    if (core.Is.stringValue(envVars.storageFileRoot)) {
-        envVars.stateFilename ??= "engine-state.json";
-        envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
-        envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
-    }
-    const coreConfig = {
-        debug: core.Coerce.boolean(envVars.debug) ?? false,
-        types: {}
-    };
-    await configureEntityStorage(coreConfig, envVars);
-    await configureBlobStorage(coreConfig, envVars);
-    await configureVault(coreConfig, envVars);
-    await configureDlt(coreConfig, envVars);
-    await configureLogging(coreConfig, envVars);
-    await configureBackgroundTask(coreConfig, envVars);
-    await configureTaskScheduler(coreConfig, envVars);
-    await configureEventBus(coreConfig, envVars);
-    await configureTelemetry(coreConfig, envVars);
-    await configureMessaging(coreConfig, envVars);
-    await configureFaucet(coreConfig, envVars);
-    await configureWallet(coreConfig, envVars);
-    await configureNft(coreConfig, envVars);
-    await configureVerifiableStorage(coreConfig, envVars);
-    await configureIdentity(coreConfig, envVars);
-    await configureIdentityResolver(coreConfig, envVars);
-    await configureIdentityProfile(coreConfig, envVars);
-    await configureAttestation(coreConfig, envVars);
-    await configureDataProcessing(coreConfig, envVars);
-    await configureAuditableItemGraph(coreConfig, envVars);
-    await configureAuditableItemStream(coreConfig, envVars);
-    await configureDocumentManagement(coreConfig, envVars);
-    await configureVerifiableCredentialAuthentication(coreConfig, envVars);
-    await configureRightsManagement(coreConfig, envVars);
-    await configureSynchronisedStorage(coreConfig, envVars);
-    await configureFederatedCatalogue(coreConfig, envVars);
-    await configureDataSpaceConnector(coreConfig, envVars);
-    return coreConfig;
-}
-/**
- * Configures the entity storage.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureEntityStorage(coreConfig, envVars) {
-    coreConfig.types ??= {};
-    coreConfig.types.entityStorageConnector ??= [];
-    const entityStorageConnectorTypes = envVars.entityStorageConnectorType?.split(",") ?? [];
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.Memory)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.Memory
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.File)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.File,
-            options: {
-                config: { directory: envVars.storageFileRoot ?? "" },
-                folderPrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.AwsDynamoDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.AwsDynamoDb,
-            options: {
-                config: {
-                    region: envVars.awsDynamodbRegion ?? "",
-                    authMode: envVars.awsDynamodbAuthMode,
-                    accessKeyId: envVars.awsDynamodbAccessKeyId,
-                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
-                    endpoint: envVars.awsDynamodbEndpoint
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.AzureCosmosDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.AzureCosmosDb,
-            options: {
-                config: {
-                    endpoint: envVars.azureCosmosdbEndpoint ?? "",
-                    key: envVars.azureCosmosdbKey ?? "",
-                    databaseId: envVars.azureCosmosdbDatabaseId ?? "",
-                    containerId: envVars.azureCosmosdbContainerId ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.GcpFirestoreDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.GcpFirestoreDb,
-            options: {
-                config: {
-                    projectId: envVars.gcpFirestoreProjectId ?? "",
-                    credentials: envVars.gcpFirestoreCredentials ?? "",
-                    databaseId: envVars.gcpFirestoreDatabaseId ?? "",
-                    collectionName: envVars.gcpFirestoreCollectionName ?? "",
-                    endpoint: envVars.gcpFirestoreApiEndpoint ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.ScyllaDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.ScyllaDb,
-            options: {
-                config: {
-                    hosts: envVars.scylladbHosts?.split(",") ?? [],
-                    localDataCenter: envVars.scylladbLocalDataCenter ?? "",
-                    keyspace: envVars.scylladbKeyspace ?? "",
-                    port: core.Coerce.integer(envVars.scylladbPort)
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.MySqlDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.MySqlDb,
-            options: {
-                config: {
-                    host: envVars.mySqlHost ?? "",
-                    port: core.Coerce.integer(envVars.mySqlPort),
-                    user: envVars.mySqlUser ?? "",
-                    password: envVars.mySqlPassword ?? "",
-                    database: envVars.mySqlDatabase ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.MongoDb)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.MongoDb,
-            options: {
-                config: {
-                    host: envVars.mongoDbHost ?? "",
-                    port: core.Coerce.integer(envVars.mongoDbPort),
-                    user: envVars.mongoDbUser ?? "",
-                    password: envVars.mongoDbPassword ?? "",
-                    database: envVars.mongoDbDatabase ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (entityStorageConnectorTypes.includes(engineTypes.EntityStorageConnectorType.PostgreSql)) {
-        coreConfig.types.entityStorageConnector.push({
-            type: engineTypes.EntityStorageConnectorType.PostgreSql,
-            options: {
-                config: {
-                    host: envVars.postgreSqlHost ?? "",
-                    port: core.Coerce.integer(envVars.postgreSqlPort),
-                    user: envVars.postgreSqlUser ?? "",
-                    password: envVars.postgreSqlPassword ?? "",
-                    database: envVars.postgreSqlDatabase ?? ""
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    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)) {
-        for (const config of coreConfig.types.entityStorageConnector) {
-            if (config.type === defaultEntityStorageConnectorType) {
-                config.isDefault = true;
-                break;
-            }
-        }
-    }
-}
-/**
- * Configures the blob storage.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureBlobStorage(coreConfig, envVars) {
-    coreConfig.types.blobStorageConnector ??= [];
-    const blobStorageConnectorTypes = envVars.blobStorageConnectorType?.split(",") ?? [];
-    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.Memory)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: engineTypes.BlobStorageConnectorType.Memory
-        });
-    }
-    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.File)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: engineTypes.BlobStorageConnectorType.File,
-            options: {
-                config: {
-                    directory: core.Is.stringValue(envVars.storageFileRoot)
-                        ? path.join(envVars.storageFileRoot, "blob-storage")
-                        : ""
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.Ipfs)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: engineTypes.BlobStorageConnectorType.Ipfs,
-            options: {
-                config: {
-                    apiUrl: envVars.ipfsApiUrl ?? "",
-                    bearerToken: envVars.ipfsBearerToken
-                }
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.AwsS3)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: engineTypes.BlobStorageConnectorType.AwsS3,
-            options: {
-                config: {
-                    region: envVars.awsS3Region ?? "",
-                    bucketName: envVars.awsS3BucketName ?? "",
-                    authMode: envVars.awsS3AuthMode,
-                    accessKeyId: envVars.awsS3AccessKeyId,
-                    secretAccessKey: envVars.awsS3SecretAccessKey,
-                    endpoint: envVars.awsS3Endpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.AzureStorage)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: engineTypes.BlobStorageConnectorType.AzureStorage,
-            options: {
-                config: {
-                    accountName: envVars.azureStorageAccountName ?? "",
-                    accountKey: envVars.azureStorageAccountKey ?? "",
-                    containerName: envVars.azureStorageContainerName ?? "",
-                    endpoint: envVars.azureStorageEndpoint ?? ""
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (blobStorageConnectorTypes.includes(engineTypes.BlobStorageConnectorType.GcpStorage)) {
-        coreConfig.types.blobStorageConnector.push({
-            type: engineTypes.BlobStorageConnectorType.GcpStorage,
-            options: {
-                config: {
-                    projectId: envVars.gcpStorageProjectId ?? "",
-                    credentials: envVars.gcpStorageCredentials ?? "",
-                    bucketName: envVars.gcpStorageBucketName ?? "",
-                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (core.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 (core.Is.stringValue(envVars.blobStorageConnectorPublic) &&
-                config.type === envVars.blobStorageConnectorPublic) {
-                config.features ??= [];
-                config.features.push("public");
-                break;
-            }
-        }
-    }
-    if (coreConfig.types.blobStorageConnector.length > 0) {
-        coreConfig.types.blobStorageComponent ??= [];
-        coreConfig.types.blobStorageComponent.push({
-            type: engineTypes.BlobStorageComponentType.Service,
-            options: {
-                config: {
-                    vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? (envVars.blobStorageEncryptionKeyId ?? BLOB_STORAGE_ENCRYPTION_KEY_ID)
-                        : undefined
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the logging.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureLogging(coreConfig, envVars) {
-    coreConfig.types.loggingConnector ??= [];
-    const loggingConnectorTypes = (envVars.loggingConnector ?? "").split(",");
-    let additionalConnectorCount = 0;
-    for (const loggingConnector of loggingConnectorTypes) {
-        if (loggingConnector === engineTypes.LoggingConnectorType.Console) {
-            coreConfig.types.loggingConnector.push({
-                type: engineTypes.LoggingConnectorType.Console,
-                options: {
-                    config: {
-                        translateMessages: true,
-                        hideGroups: true
-                    }
-                }
-            });
-            additionalConnectorCount++;
-        }
-        else if (loggingConnector === engineTypes.LoggingConnectorType.EntityStorage) {
-            coreConfig.types.loggingConnector.push({
-                type: engineTypes.LoggingConnectorType.EntityStorage
-            });
-            additionalConnectorCount++;
-        }
-    }
-    // If more than one logging connector, then we need to add a multi connector
-    // and set it as the default one
-    if (additionalConnectorCount > 1) {
-        coreConfig.types.loggingConnector.push({
-            type: engineTypes.LoggingConnectorType.Multi,
-            options: {
-                loggingConnectorTypes
-            },
-            isDefault: true
-        });
-    }
-    else if (additionalConnectorCount > 0) {
-        // If only one connector, then we set it as the default one
-        coreConfig.types.loggingConnector[coreConfig.types.loggingConnector.length - 1].isDefault =
-            true;
-    }
-    if (additionalConnectorCount > 0) {
-        coreConfig.types.loggingComponent ??= [];
-        // We set the isDefault flag so that other components will get this service by default
-        // and not the generic one from the engine core
-        coreConfig.types.loggingComponent.push({ type: engineTypes.LoggingComponentType.Service, isDefault: true });
-    }
-}
-/**
- * Configures the vault.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureVault(coreConfig, envVars) {
-    coreConfig.types.vaultConnector ??= [];
-    if (envVars.vaultConnector === engineTypes.VaultConnectorType.EntityStorage) {
-        coreConfig.types.vaultConnector.push({
-            type: engineTypes.VaultConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.vaultConnector === engineTypes.VaultConnectorType.Hashicorp) {
-        coreConfig.types.vaultConnector.push({
-            type: engineTypes.VaultConnectorType.Hashicorp,
-            options: {
-                config: {
-                    endpoint: envVars.hashicorpVaultEndpoint ?? "",
-                    token: envVars.hashicorpVaultToken ?? ""
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the background task.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureBackgroundTask(coreConfig, envVars) {
-    coreConfig.types.backgroundTaskConnector ??= [];
-    if (envVars.backgroundTaskConnector === engineTypes.BackgroundTaskConnectorType.EntityStorage) {
-        coreConfig.types.backgroundTaskConnector.push({
-            type: engineTypes.BackgroundTaskConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the event bud.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureEventBus(coreConfig, envVars) {
-    coreConfig.types.eventBusConnector ??= [];
-    if (envVars.eventBusConnector === engineTypes.EventBusConnectorType.Local) {
-        coreConfig.types.eventBusConnector.push({
-            type: engineTypes.EventBusConnectorType.Local
-        });
-    }
-    if (coreConfig.types.eventBusConnector.length > 0) {
-        coreConfig.types.eventBusComponent ??= [];
-        coreConfig.types.eventBusComponent.push({ type: engineTypes.EventBusComponentType.Service });
-    }
-}
-/**
- * Configures the telemetry.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureTelemetry(coreConfig, envVars) {
-    coreConfig.types.telemetryConnector ??= [];
-    if (envVars.telemetryConnector === engineTypes.TelemetryConnectorType.EntityStorage) {
-        coreConfig.types.telemetryConnector.push({
-            type: engineTypes.TelemetryConnectorType.EntityStorage
-        });
-    }
-    if (coreConfig.types.telemetryConnector.length > 0) {
-        coreConfig.types.telemetryComponent ??= [];
-        coreConfig.types.telemetryComponent.push({ type: engineTypes.TelemetryComponentType.Service });
-    }
-}
-/**
- * Configures the messaging.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureMessaging(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.messagingEnabled) ?? false) {
-        coreConfig.types.messagingEmailConnector ??= [];
-        coreConfig.types.messagingSmsConnector ??= [];
-        coreConfig.types.messagingPushNotificationConnector ??= [];
-        if (envVars.messagingEmailConnector === engineTypes.MessagingEmailConnectorType.EntityStorage) {
-            coreConfig.types.messagingEmailConnector.push({
-                type: engineTypes.MessagingEmailConnectorType.EntityStorage
-            });
-        }
-        else if (envVars.messagingEmailConnector === engineTypes.MessagingEmailConnectorType.Aws) {
-            coreConfig.types.messagingEmailConnector.push({
-                type: engineTypes.MessagingEmailConnectorType.Aws,
-                options: {
-                    config: {
-                        region: envVars.awsSesRegion ?? "",
-                        authMode: envVars.awsSesAuthMode,
-                        accessKeyId: envVars.awsSesAccessKeyId,
-                        secretAccessKey: envVars.awsSesSecretAccessKey,
-                        endpoint: envVars.awsSesEndpoint
-                    }
-                }
-            });
-        }
-        if (envVars.messagingSmsConnector === engineTypes.MessagingSmsConnectorType.EntityStorage) {
-            coreConfig.types.messagingSmsConnector.push({
-                type: engineTypes.MessagingSmsConnectorType.EntityStorage
-            });
-        }
-        else if (envVars.messagingSmsConnector === engineTypes.MessagingSmsConnectorType.Aws) {
-            coreConfig.types.messagingSmsConnector.push({
-                type: engineTypes.MessagingSmsConnectorType.Aws,
-                options: {
-                    config: {
-                        region: envVars.awsSesRegion ?? "",
-                        authMode: envVars.awsSesAuthMode,
-                        accessKeyId: envVars.awsSesAccessKeyId,
-                        secretAccessKey: envVars.awsSesSecretAccessKey,
-                        endpoint: envVars.awsSesEndpoint
-                    }
-                }
-            });
-        }
-        if (envVars.messagingPushNotificationConnector ===
-            engineTypes.MessagingPushNotificationConnectorType.EntityStorage) {
-            coreConfig.types.messagingPushNotificationConnector.push({
-                type: engineTypes.MessagingPushNotificationConnectorType.EntityStorage
-            });
-        }
-        else if (envVars.messagingPushNotificationConnector === engineTypes.MessagingPushNotificationConnectorType.Aws) {
-            coreConfig.types.messagingPushNotificationConnector.push({
-                type: engineTypes.MessagingPushNotificationConnectorType.Aws,
-                options: {
-                    config: {
-                        region: envVars.awsSesRegion ?? "",
-                        authMode: envVars.awsSesAuthMode,
-                        accessKeyId: envVars.awsSesAccessKeyId,
-                        secretAccessKey: envVars.awsSesSecretAccessKey,
-                        endpoint: envVars.awsSesEndpoint,
-                        applicationsSettings: core.Is.json(envVars.awsMessagingPushNotificationApplications)
-                            ? JSON.parse(envVars.awsMessagingPushNotificationApplications)
-                            : []
-                    }
-                }
-            });
-        }
-        const templates = core.Is.arrayValue(envVars.messagingTemplates)
-            ? envVars.messagingTemplates
-            : undefined;
-        coreConfig.types.messagingAdminComponent ??= [];
-        coreConfig.types.messagingAdminComponent.push({
-            type: engineTypes.MessagingAdminComponentType.Service,
-            options: {
-                config: {
-                    templates
-                }
-            }
-        });
-        coreConfig.types.messagingComponent ??= [];
-        coreConfig.types.messagingComponent.push({ type: engineTypes.MessagingComponentType.Service });
-    }
-}
-/**
- * Configures the faucet.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureFaucet(coreConfig, envVars) {
-    coreConfig.types.faucetConnector ??= [];
-    if (envVars.faucetConnector === engineTypes.FaucetConnectorType.EntityStorage) {
-        coreConfig.types.faucetConnector.push({
-            type: engineTypes.FaucetConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.faucetConnector === engineTypes.FaucetConnectorType.Iota) {
-        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
-        coreConfig.types.faucetConnector.push({
-            type: engineTypes.FaucetConnectorType.Iota,
-            options: {
-                config: {
-                    endpoint: envVars.iotaFaucetEndpoint ?? "",
-                    clientOptions: dltConfig?.options?.config?.clientOptions ?? { url: "" },
-                    network: dltConfig?.options?.config?.network ?? ""
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the wallet.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureWallet(coreConfig, envVars) {
-    coreConfig.types.walletConnector ??= [];
-    if (envVars.walletConnector === engineTypes.WalletConnectorType.EntityStorage) {
-        coreConfig.types.walletConnector.push({
-            type: engineTypes.WalletConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.walletConnector === engineTypes.WalletConnectorType.Iota) {
-        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
-        coreConfig.types.walletConnector.push({
-            type: engineTypes.WalletConnectorType.Iota,
-            options: {
-                config: dltConfig?.options?.config ?? {}
-            }
-        });
-    }
-}
-/**
- * Configures the NFT.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureNft(coreConfig, envVars) {
-    coreConfig.types.nftConnector ??= [];
-    if (envVars.nftConnector === engineTypes.NftConnectorType.EntityStorage) {
-        coreConfig.types.nftConnector.push({
-            type: engineTypes.NftConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.nftConnector === engineTypes.NftConnectorType.Iota) {
-        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
-        coreConfig.types.nftConnector.push({
-            type: engineTypes.NftConnectorType.Iota,
-            options: {
-                config: dltConfig?.options?.config ?? {}
-            }
-        });
-    }
-    if (coreConfig.types.nftConnector.length > 0) {
-        coreConfig.types.nftComponent ??= [];
-        coreConfig.types.nftComponent.push({ type: engineTypes.NftComponentType.Service });
-    }
-}
-/**
- * Configures the verifiable storage.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureVerifiableStorage(coreConfig, envVars) {
-    coreConfig.types.verifiableStorageConnector ??= [];
-    if (envVars.verifiableStorageConnector === engineTypes.VerifiableStorageConnectorType.EntityStorage) {
-        coreConfig.types.verifiableStorageConnector.push({
-            type: engineTypes.VerifiableStorageConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.verifiableStorageConnector === engineTypes.VerifiableStorageConnectorType.Iota) {
-        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
-        coreConfig.types.verifiableStorageConnector.push({
-            type: engineTypes.VerifiableStorageConnectorType.Iota,
-            options: {
-                config: dltConfig?.options?.config ?? {}
-            }
-        });
-    }
-    if (coreConfig.types.verifiableStorageConnector.length > 0) {
-        coreConfig.types.verifiableStorageComponent ??= [];
-        coreConfig.types.verifiableStorageComponent.push({
-            type: engineTypes.VerifiableStorageComponentType.Service
-        });
-        coreConfig.types.immutableProofComponent ??= [];
-        coreConfig.types.immutableProofComponent.push({
-            type: engineTypes.ImmutableProofComponentType.Service,
-            options: {
-                config: {
-                    verificationMethodId: envVars.immutableProofVerificationMethodId ?? IMMUTABLE_PROOF_VERIFICATION_METHOD_ID
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the identity.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureIdentity(coreConfig, envVars) {
-    coreConfig.types.identityConnector ??= [];
-    if (envVars.identityConnector === engineTypes.IdentityConnectorType.EntityStorage) {
-        coreConfig.types.identityConnector.push({
-            type: engineTypes.IdentityConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.identityConnector === engineTypes.IdentityConnectorType.Iota) {
-        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
-        coreConfig.types.identityConnector.push({
-            type: engineTypes.IdentityConnectorType.Iota,
-            options: {
-                config: dltConfig?.options?.config ?? {}
-            }
-        });
-    }
-    if (coreConfig.types.identityConnector.length > 0) {
-        coreConfig.types.identityComponent ??= [];
-        coreConfig.types.identityComponent.push({ type: engineTypes.IdentityComponentType.Service });
-    }
-}
-/**
- * Configures the identity resolver.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureIdentityResolver(coreConfig, envVars) {
-    coreConfig.types.identityResolverConnector ??= [];
-    if (envVars.identityResolverConnector === engineTypes.IdentityResolverConnectorType.EntityStorage) {
-        coreConfig.types.identityResolverConnector.push({
-            type: engineTypes.IdentityResolverConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.identityResolverConnector === engineTypes.IdentityResolverConnectorType.Iota) {
-        const dltConfig = engineTypes.EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", engineTypes.DltConfigType.Iota);
-        coreConfig.types.identityResolverConnector.push({
-            type: engineTypes.IdentityResolverConnectorType.Iota,
-            options: {
-                config: dltConfig?.options?.config ?? {}
-            }
-        });
-    }
-    else if (envVars.identityResolverConnector === engineTypes.IdentityResolverConnectorType.Universal) {
-        coreConfig.types.identityResolverConnector.push({
-            type: engineTypes.IdentityResolverConnectorType.Universal,
-            options: {
-                config: {
-                    endpoint: envVars.universalResolverEndpoint ?? ""
-                }
-            }
-        });
-    }
-    if (coreConfig.types.identityResolverConnector.length > 0) {
-        coreConfig.types.identityResolverComponent ??= [];
-        coreConfig.types.identityResolverComponent.push({
-            type: engineTypes.IdentityResolverComponentType.Service
-        });
-    }
-}
-/**
- * Configures the identity profile.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureIdentityProfile(coreConfig, envVars) {
-    coreConfig.types.identityProfileConnector ??= [];
-    if (envVars.identityProfileConnector === engineTypes.IdentityConnectorType.EntityStorage) {
-        coreConfig.types.identityProfileConnector.push({
-            type: engineTypes.IdentityProfileConnectorType.EntityStorage
-        });
-    }
-    if (coreConfig.types.identityProfileConnector.length > 0) {
-        coreConfig.types.identityProfileComponent ??= [];
-        coreConfig.types.identityProfileComponent.push({ type: engineTypes.IdentityProfileComponentType.Service });
-    }
-}
-/**
- * Configures the attestation.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureAttestation(coreConfig, envVars) {
-    coreConfig.types.attestationConnector ??= [];
-    if (envVars.attestationConnector === engineTypes.AttestationConnectorType.Nft) {
-        coreConfig.types.attestationConnector.push({
-            type: engineTypes.AttestationConnectorType.Nft
-        });
-    }
-    if (coreConfig.types.attestationConnector.length > 0) {
-        coreConfig.types.attestationComponent ??= [];
-        coreConfig.types.attestationComponent.push({
-            type: engineTypes.AttestationComponentType.Service,
-            options: {
-                config: {
-                    verificationMethodId: envVars.attestationVerificationMethodId ?? ATTESTATION_VERIFICATION_METHOD_ID
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the auditable item graph.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureAuditableItemGraph(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.auditableItemGraphEnabled) ?? false) {
-        coreConfig.types.auditableItemGraphComponent ??= [];
-        coreConfig.types.auditableItemGraphComponent.push({
-            type: engineTypes.AuditableItemGraphComponentType.Service
-        });
-    }
-}
-/**
- * Configures the auditable item stream.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureAuditableItemStream(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.auditableItemStreamEnabled) ?? false) {
-        coreConfig.types.auditableItemStreamComponent ??= [];
-        coreConfig.types.auditableItemStreamComponent.push({
-            type: engineTypes.AuditableItemStreamComponentType.Service
-        });
-    }
-}
-/**
- * Configures the data processing.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureDataProcessing(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.dataProcessingEnabled) ?? false) {
-        coreConfig.types.dataProcessingComponent ??= [];
-        coreConfig.types.dataProcessingComponent.push({ type: engineTypes.DataProcessingComponentType.Service });
-        coreConfig.types.dataConverterConnector ??= [];
-        const converterConnectors = envVars.dataConverterConnectors?.split(",") ?? [];
-        for (const converterConnector of converterConnectors) {
-            if (converterConnector === engineTypes.DataConverterConnectorType.Json) {
-                coreConfig.types.dataConverterConnector.push({
-                    type: engineTypes.DataConverterConnectorType.Json
-                });
-            }
-            else if (converterConnector === engineTypes.DataConverterConnectorType.Xml) {
-                coreConfig.types.dataConverterConnector.push({
-                    type: engineTypes.DataConverterConnectorType.Xml
-                });
-            }
-        }
-        coreConfig.types.dataExtractorConnector ??= [];
-        const extractorConnectors = envVars.dataExtractorConnectors?.split(",") ?? [];
-        for (const extractorConnector of extractorConnectors) {
-            if (extractorConnector === engineTypes.DataExtractorConnectorType.JsonPath) {
-                coreConfig.types.dataExtractorConnector.push({
-                    type: engineTypes.DataExtractorConnectorType.JsonPath
-                });
-            }
-        }
-    }
-}
-/**
- * Configures the document management.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureDocumentManagement(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.documentManagementEnabled) ?? false) {
-        coreConfig.types.documentManagementComponent ??= [];
-        coreConfig.types.documentManagementComponent.push({
-            type: engineTypes.DocumentManagementComponentType.Service
-        });
-    }
-}
-/**
- * Configures the verifiable credential authentication.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureVerifiableCredentialAuthentication(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
-        // Can only perform VC authentication if identity component is available
-        coreConfig.types.authenticationGeneratorComponent ??= [];
-        coreConfig.types.authenticationGeneratorComponent.push({
-            type: engineTypes.AuthenticationGeneratorComponentType.VerifiableCredential,
-            options: {
-                config: {
-                    verificationMethodId: envVars.vcAuthenticationVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID
-                }
-            },
-            features: ["verifiable-credential"]
-        });
-    }
-}
-/**
- * Configures the rights management.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureRightsManagement(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
-        coreConfig.types.rightsManagementPapComponent ??= [];
-        coreConfig.types.rightsManagementPapComponent.push({
-            type: engineTypes.RightsManagementPapComponentType.Service
-        });
-        coreConfig.types.rightsManagementPmpComponent ??= [];
-        coreConfig.types.rightsManagementPmpComponent.push({
-            type: engineTypes.RightsManagementPmpComponentType.Service
-        });
-        coreConfig.types.rightsManagementPipComponent ??= [];
-        coreConfig.types.rightsManagementPipComponent.push({
-            type: engineTypes.RightsManagementPipComponentType.Service,
-            options: {
-                informationModulesConfig: core.Is.arrayValue(envVars.rightsManagementInformationSources)
-                    ? envVars.rightsManagementInformationSources
-                    : undefined
-            }
-        });
-        coreConfig.types.rightsManagementPxpComponent ??= [];
-        coreConfig.types.rightsManagementPxpComponent.push({
-            type: engineTypes.RightsManagementPxpComponentType.Service,
-            options: {
-                actionModulesConfig: core.Is.arrayValue(envVars.rightsManagementExecutionActions)
-                    ? envVars.rightsManagementExecutionActions
-                    : undefined
-            }
-        });
-        coreConfig.types.rightsManagementPdpComponent ??= [];
-        coreConfig.types.rightsManagementPdpComponent.push({
-            type: engineTypes.RightsManagementPdpComponentType.Service,
-            options: {
-                arbiterModulesConfig: core.Is.arrayValue(envVars.rightsManagementArbiters)
-                    ? envVars.rightsManagementArbiters
-                    : undefined
-            }
-        });
-        coreConfig.types.rightsManagementPepComponent ??= [];
-        coreConfig.types.rightsManagementPepComponent.push({
-            type: engineTypes.RightsManagementPepComponentType.Service,
-            options: {
-                processorModulesConfig: core.Is.arrayValue(envVars.rightsManagementEnforcementProcessors)
-                    ? envVars.rightsManagementEnforcementProcessors
-                    : undefined
-            }
-        });
-        coreConfig.types.rightsManagementPnpComponent ??= [];
-        coreConfig.types.rightsManagementPnpComponent.push({
-            type: engineTypes.RightsManagementPnpComponentType.Service,
-            options: {
-                negotiatorModulesConfig: core.Is.arrayValue(envVars.rightsManagementNegotiators)
-                    ? envVars.rightsManagementNegotiators
-                    : undefined,
-                requesterModulesConfig: core.Is.arrayValue(envVars.rightsManagementRequesters)
-                    ? envVars.rightsManagementRequesters
-                    : undefined,
-                config: {
-                    baseCallbackUrl: envVars.rightsManagementBaseCallbackUrl ?? "",
-                    offers: core.Is.arrayValue(envVars.rightsManagementOffers)
-                        ? envVars.rightsManagementOffers
-                        : [],
-                    negotiationComponentCreator: async (url) => new rightsManagementRestClient.PolicyNegotiationPointRestClient({ endpoint: url })
-                }
-            }
-        });
-        coreConfig.types.rightsManagementPnapComponent ??= [];
-        coreConfig.types.rightsManagementPnapComponent.push({
-            type: engineTypes.RightsManagementPnapComponentType.Service
-        });
-        coreConfig.types.rightsManagementDapComponent ??= [];
-        coreConfig.types.rightsManagementDapComponent.push({
-            type: engineTypes.RightsManagementDapComponentType.Service
-        });
-        coreConfig.types.rightsManagementDarpComponent ??= [];
-        coreConfig.types.rightsManagementDarpComponent.push({
-            type: engineTypes.RightsManagementDarpComponentType.Service,
-            options: {
-                config: {
-                    dataAccessComponentCreator: async (url) => new rightsManagementRestClient.DataAccessPointRestClient({ endpoint: url })
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the task scheduler.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureTaskScheduler(coreConfig, envVars) {
-    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.
- */
-async function configureSynchronisedStorage(coreConfig, envVars) {
-    if (core.Is.arrayValue(coreConfig.types.identityResolverComponent) &&
-        (core.Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false)) {
-        // Check if the config provides a custom verifiable storage key id
-        let verifiableStorageKeyId = core.Coerce.string(envVars.synchronisedStorageVerifiableStorageKeyId);
-        if (!core.Is.stringValue(verifiableStorageKeyId)) {
-            // No custom key so default to the network setting
-            verifiableStorageKeyId = envVars.iotaNetwork;
-        }
-        coreConfig.types.synchronisedStorageComponent ??= [];
-        coreConfig.types.synchronisedStorageComponent.push({
-            type: engineTypes.SynchronisedStorageComponentType.Service,
-            options: {
-                config: {
-                    verifiableStorageKeyId: verifiableStorageKeyId ?? "",
-                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId ??
-                        SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID,
-                    entityUpdateIntervalMinutes: core.Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
-                    consolidationIntervalMinutes: core.Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
-                    consolidationBatchSize: core.Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
-                    maxConsolidations: core.Coerce.number(envVars.synchronisedStorageMaxConsolidations)
-                }
-            }
-        });
-        // If there is a trusted url set, we need to add a client
-        // and give it a feature of trusted so that when the synchronised
-        // storage is created it can pickup the correct component
-        if (core.Is.stringValue(envVars.synchronisedStorageTrustedUrl)) {
-            coreConfig.types.synchronisedStorageComponent.push({
-                type: engineTypes.SynchronisedStorageComponentType.RestClient,
-                options: {
-                    endpoint: envVars.synchronisedStorageTrustedUrl
-                },
-                features: ["trusted"]
-            });
-        }
-    }
-}
-/**
- * Configures the federated catalogue.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureFederatedCatalogue(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) {
-        coreConfig.types.federatedCatalogueComponent ??= [];
-        coreConfig.types.federatedCatalogueComponent.push({
-            type: engineTypes.FederatedCatalogueComponentType.Service,
-            options: {
-                config: {
-                    subResourceCacheTtlMs: core.Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: core.Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the data space connector.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureDataSpaceConnector(coreConfig, envVars) {
-    if (core.Coerce.boolean(envVars.dataSpaceConnectorEnabled) ?? false) {
-        coreConfig.types.dataSpaceConnectorComponent ??= [];
-        coreConfig.types.dataSpaceConnectorComponent.push({
-            type: engineTypes.DataSpaceConnectorComponentType.Service,
-            options: {
-                config: {
-                    retainActivityLogsFor: core.Coerce.number(envVars.dataSpaceConnectorRetainActivityLogsFor),
-                    activityLogsCleanUpInterval: core.Coerce.number(envVars.dataSpaceConnectorActivityLogsCleanUpInterval)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the DLT.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureDlt(coreConfig, envVars) {
-    // Create centralized DLT configuration for IOTA if essential IOTA variables are set
-    if (core.Is.stringValue(envVars.iotaNodeEndpoint) && core.Is.stringValue(envVars.iotaNetwork)) {
-        coreConfig.types.dltConfig ??= [];
-        const gasStationConfig = core.Is.stringValue(envVars.iotaGasStationEndpoint) &&
-            core.Is.stringValue(envVars.iotaGasStationAuthToken)
-            ? {
-                gasStationUrl: envVars.iotaGasStationEndpoint,
-                gasStationAuthToken: envVars.iotaGasStationAuthToken
-            }
-            : undefined;
-        coreConfig.types.dltConfig.push({
-            type: engineTypes.DltConfigType.Iota,
-            isDefault: true,
-            options: {
-                config: {
-                    clientOptions: {
-                        url: envVars.iotaNodeEndpoint ?? ""
-                    },
-                    network: envVars.iotaNetwork ?? "",
-                    coinType: core.Coerce.number(envVars.iotaCoinType),
-                    gasStation: gasStationConfig
-                }
-            }
-        });
-    }
-}
-
-/**
- * Handles the configuration of the server.
- * @param envVars The environment variables for the engine server.
- * @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 config for the core and the server.
- */
-async function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath, favIconPath) {
-    const webServerOptions = {
-        port: core.Coerce.number(envVars.port),
-        host: core.Coerce.string(envVars.host),
-        methods: core.Is.stringValue(envVars.httpMethods)
-            ? envVars.httpMethods.split(",")
-            : undefined,
-        allowedHeaders: core.Is.stringValue(envVars.httpAllowedHeaders)
-            ? envVars.httpAllowedHeaders.split(",")
-            : undefined,
-        exposedHeaders: core.Is.stringValue(envVars.httpExposedHeaders)
-            ? envVars.httpExposedHeaders.split(",")
-            : undefined,
-        corsOrigins: core.Is.stringValue(envVars.corsOrigins) ? envVars.corsOrigins.split(",") : undefined
-    };
-    const serverConfig = {
-        ...coreEngineConfig,
-        web: webServerOptions,
-        types: {
-            ...coreEngineConfig.types,
-            informationComponent: [
-                {
-                    type: engineServerTypes.InformationComponentType.Service,
-                    options: {
-                        config: {
-                            serverInfo,
-                            openApiSpecPath,
-                            favIconPath
-                        }
-                    }
-                }
-            ]
-        }
-    };
-    if (core.Is.stringValue(envVars.mimeTypeProcessors)) {
-        const mimeTypeProcessors = envVars.mimeTypeProcessors.split(",");
-        if (core.Is.arrayValue(mimeTypeProcessors)) {
-            serverConfig.types.mimeTypeProcessor ??= [];
-            for (const mimeTypeProcessor of mimeTypeProcessors) {
-                serverConfig.types.mimeTypeProcessor.push({
-                    type: mimeTypeProcessor
-                });
-            }
-        }
-    }
-    serverConfig.types.restRouteProcessor ??= [];
-    serverConfig.types.socketRouteProcessor ??= [];
-    const features = getFeatures(envVars);
-    const hasNodeIdentity = features.includes(NodeFeatures.NodeIdentity);
-    if (hasNodeIdentity) {
-        serverConfig.types.restRouteProcessor.push({
-            type: engineServerTypes.RestRouteProcessorType.NodeIdentity
-        });
-        serverConfig.types.socketRouteProcessor.push({
-            type: engineServerTypes.SocketRouteProcessorType.NodeIdentity
-        });
-    }
-    if (!coreEngineConfig.silent) {
-        const includeBody = core.Coerce.boolean(envVars.routeLoggingIncludeBody) ?? coreEngineConfig.debug;
-        const fullBase64 = core.Coerce.boolean(envVars.routeLoggingFullBase64) ?? false;
-        const obfuscateProperties = core.Is.stringValue(envVars.routeLoggingObfuscateProperties)
-            ? envVars.routeLoggingObfuscateProperties.split(",")
-            : undefined;
-        serverConfig.types.restRouteProcessor.push({
-            type: engineServerTypes.RestRouteProcessorType.Logging,
-            options: {
-                config: {
-                    includeBody,
-                    fullBase64,
-                    obfuscateProperties
-                }
-            }
-        });
-        serverConfig.types.socketRouteProcessor.push({
-            type: engineServerTypes.SocketRouteProcessorType.Logging,
-            options: {
-                config: {
-                    includeBody,
-                    fullBase64,
-                    obfuscateProperties
-                }
-            }
-        });
-    }
-    serverConfig.types.restRouteProcessor.push({
-        type: engineServerTypes.RestRouteProcessorType.RestRoute,
-        options: {
-            config: {
-                includeErrorStack: coreEngineConfig.debug
-            }
-        }
-    });
-    serverConfig.types.socketRouteProcessor.push({
-        type: engineServerTypes.SocketRouteProcessorType.SocketRoute,
-        options: {
-            config: {
-                includeErrorStack: coreEngineConfig.debug
-            }
-        }
-    });
-    const authAdminProcessorType = envVars.authAdminProcessorType;
-    if (authAdminProcessorType === engineServerTypes.AuthenticationAdminComponentType.EntityStorage) {
-        serverConfig.types.authenticationAdminComponent ??= [];
-        serverConfig.types.authenticationAdminComponent.push({
-            type: engineServerTypes.AuthenticationAdminComponentType.EntityStorage,
-            options: {
-                config: {}
-            }
-        });
-    }
-    const authProcessorType = envVars.authProcessorType;
-    if (authProcessorType === engineServerTypes.AuthenticationComponentType.EntityStorage) {
-        serverConfig.types.authenticationComponent ??= [];
-        serverConfig.types.authenticationComponent.push({
-            type: engineServerTypes.AuthenticationComponentType.EntityStorage,
-            options: {
-                config: {
-                    signingKeyName: envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID
-                }
-            }
-        });
-        serverConfig.types.restRouteProcessor.push({
-            type: engineServerTypes.RestRouteProcessorType.AuthHeader,
-            options: {
-                config: {
-                    signingKeyName: envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID
-                }
-            }
-        });
-        serverConfig.types.socketRouteProcessor.push({
-            type: engineServerTypes.SocketRouteProcessorType.AuthHeader,
-            options: {
-                config: {
-                    signingKeyName: envVars.authSigningKeyId ?? AUTH_SIGNING_KEY_ID
-                }
-            }
-        });
-    }
-    if (core.Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
-        serverConfig.types.restRouteProcessor.push({
-            type: engineServerTypes.RestRouteProcessorType.AuthVerifiableCredential
-        });
-        serverConfig.types.socketRouteProcessor.push({
-            type: engineServerTypes.SocketRouteProcessorType.AuthVerifiableCredential
-        });
-    }
-    engineServer.addDefaultRestPaths(serverConfig);
-    engineServer.addDefaultSocketPaths(serverConfig);
-    return serverConfig;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Handles the configuration of the extensions.
- * @param envVars The environment variables for the node.
- * @param nodeEngineConfig The node engine config.
- * @returns The config for the core and the server.
- */
-async function extensionsConfiguration(envVars, nodeEngineConfig) {
-    if (core.Is.stringValue(envVars.extensions)) {
-        const extensions = envVars.extensions.split(",");
-        for (const extension of extensions) {
-            let initialiseConfigMethod;
-            try {
-                cliCore.CLIDisplay.value(core.I18n.formatMessage("node.extensionLoading"), extension);
-                initialiseConfigMethod = await modules.ModuleHelper.getModuleMethod(extension, "extensionInitialise");
-            }
-            catch (err) {
-                throw new core.GeneralError("node", "extensionLoadingError", { extension }, err);
-            }
-            if (core.Is.function(initialiseConfigMethod)) {
-                await initialiseConfigMethod(envVars, nodeEngineConfig);
-            }
-        }
-    }
-    return nodeEngineConfig;
-}
-/**
- * Handles the initialisation of the extensions when the engine has been constructed.
- * @param envVars The environment variables for the node.
- * @param engineCore The engine core instance.
- * @returns Nothing.
- */
-async function extensionsInitialiseEngine(envVars, engineCore) {
-    if (core.Is.stringValue(envVars.extensions)) {
-        const extensions = envVars.extensions.split(",");
-        for (const extension of extensions) {
-            let initialiseEngineMethod;
-            try {
-                engineCore.logInfo(core.I18n.formatMessage("node.extensionInitialisingEngine", { extension }));
-                initialiseEngineMethod =
-                    await modules.ModuleHelper.getModuleMethod(extension, "extensionInitialiseEngine");
-            }
-            catch { }
-            if (core.Is.function(initialiseEngineMethod)) {
-                await initialiseEngineMethod(engineCore);
-            }
-        }
-    }
-}
-/**
- * Handles the initialisation of the extensions when the engine server has been constructed.
- * @param envVars The environment variables for the node.
- * @param engineCore The engine core instance.
- * @param engineServer The engine server instance.
- * @returns Nothing.
- */
-async function extensionsInitialiseEngineServer(envVars, engineCore, engineServer) {
-    if (core.Is.stringValue(envVars.extensions)) {
-        const extensions = envVars.extensions.split(",");
-        for (const extension of extensions) {
-            let initialiseEngineServerMethod;
-            try {
-                engineCore.logInfo(core.I18n.formatMessage("node.extensionInitialisingEngineServer", { extension }));
-                initialiseEngineServerMethod =
-                    await modules.ModuleHelper.getModuleMethod(extension, "extensionInitialiseEngineServer");
-            }
-            catch { }
-            if (core.Is.function(initialiseEngineServerMethod)) {
-                await initialiseEngineServerMethod(engineCore, engineServer);
-            }
-        }
-    }
-}
-/**
- * Handles the shutdown of the extensions.
- * @param envVars The environment variables for the node.
- * @param engineCore The engine core instance.
- * @returns Nothing.
- */
-async function shutdownExtensions(envVars, engineCore) {
-    if (core.Is.stringValue(envVars.extensions)) {
-        const extensions = envVars.extensions.split(",");
-        for (const extension of extensions) {
-            let shutdownMethod;
-            try {
-                engineCore.logInfo(core.I18n.formatMessage("node.extensionShutdown", { extension }));
-                shutdownMethod = await modules.ModuleHelper.getModuleMethod(extension, "extensionShutdown");
-            }
-            catch { }
-            if (core.Is.function(shutdownMethod)) {
-                await shutdownMethod();
-            }
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Start the engine server.
- * @param nodeOptions Optional run options for the engine server.
- * @param nodeEngineConfig The configuration for the engine server.
- * @param envVars The environment variables.
- * @returns The engine server.
- */
-async function start(nodeOptions, nodeEngineConfig, envVars) {
-    const entityStorageConnectorType = envVars.entityStorageConnectorType?.split(",") ?? [];
-    const blobStorageConnectorType = envVars.blobStorageConnectorType?.split(",") ?? [];
-    // If the blob storage or entity storage is configured with file connectors
-    // then we need to make sure the storageFileRoot is set
-    if ((entityStorageConnectorType.includes(engineTypes.EntityStorageConnectorType.File) ||
-        blobStorageConnectorType.includes(engineTypes.BlobStorageConnectorType.File) ||
-        core.Is.empty(nodeOptions?.stateStorage)) &&
-        !core.Is.stringValue(envVars.storageFileRoot)) {
-        throw new core.GeneralError("node", "storageFileRootNotSet", {
-            storageFileRoot: `${nodeOptions?.envPrefix ?? ""}_STORAGE_FILE_ROOT`
-        });
-    }
-    // Create the engine instance using file state storage unless one is configured in options
-    const engine$1 = new engine.Engine({
-        config: nodeEngineConfig,
-        stateStorage: nodeOptions?.stateStorage ?? new engineCore.FileStateStorage(envVars.stateFilename ?? ""),
-        customBootstrap: async (core, engineContext) => bootstrap(core, engineContext, envVars)
-    });
-    // Construct the server with the engine.
-    const server = new engineServer.EngineServer({ engineCore: engine$1 });
-    // Extend the engine.
-    if (core.Is.function(nodeOptions?.extendEngine)) {
-        engine$1.logInfo(core.I18n.formatMessage("node.extendingEngine"));
-        await nodeOptions.extendEngine(engine$1);
-    }
-    await extensionsInitialiseEngine(envVars, engine$1);
-    // Extend the engine server.
-    if (core.Is.function(nodeOptions?.extendEngineServer)) {
-        engine$1.logInfo(core.I18n.formatMessage("node.extendingEngineServer"));
-        await nodeOptions?.extendEngineServer(server);
-    }
-    await extensionsInitialiseEngineServer(envVars, engine$1, server);
-    // Need to register the engine with the factory so that background tasks
-    // can clone it to spawn new instances.
-    engineModels.EngineCoreFactory.register("engine", () => engine$1);
-    // Start the server, which also starts the engine.
-    const canContinue = await server.start();
-    if (canContinue) {
-        return {
-            engine: engine$1,
-            server,
-            shutdown: async () => {
-                await server.stop();
-                await shutdownExtensions(envVars, engine$1);
-            }
-        };
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-const moduleCache = {};
-/**
- * Run the TWIN Node server.
- * @param nodeOptions Optional configuration options for running the server.
- * @returns A promise that resolves when the server is started.
- */
-async function run(nodeOptions) {
-    try {
-        nodeOptions ??= {};
-        const serverInfo = {
-            name: nodeOptions?.serverName ?? "TWIN Node Server",
-            version: nodeOptions?.serverVersion ?? "0.0.2-next.25" // x-release-please-version
-        };
-        cliCore.CLIDisplay.header(serverInfo.name, serverInfo.version, "🌩️ ");
-        if (!core.Is.stringValue(nodeOptions?.executionDirectory)) {
-            nodeOptions.executionDirectory = getExecutionDirectory();
-        }
-        cliCore.CLIDisplay.value("Execution Directory", nodeOptions.executionDirectory);
-        nodeOptions.localesDirectory =
-            nodeOptions?.localesDirectory ??
-                path.resolve(path.join(nodeOptions.executionDirectory, "dist", "locales"));
-        cliCore.CLIDisplay.value("Locales Directory", nodeOptions.localesDirectory);
-        await initialiseLocales(nodeOptions.localesDirectory);
-        if (core.Is.empty(nodeOptions?.openApiSpecFile)) {
-            const specFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "docs", "open-api", "spec.json"));
-            cliCore.CLIDisplay.value("Default OpenAPI Spec File", specFile);
-            if (await fileExists(specFile)) {
-                nodeOptions ??= {};
-                nodeOptions.openApiSpecFile = specFile;
-            }
-        }
-        else {
-            cliCore.CLIDisplay.value("OpenAPI Spec File", nodeOptions.openApiSpecFile);
-        }
-        if (core.Is.empty(nodeOptions?.favIconFile)) {
-            const favIconFile = path.resolve(path.join(nodeOptions.executionDirectory ?? "", "static", "favicon.png"));
-            cliCore.CLIDisplay.value("Default Favicon File", favIconFile);
-            if (await fileExists(favIconFile)) {
-                nodeOptions ??= {};
-                nodeOptions.favIconFile = favIconFile;
-            }
-        }
-        else {
-            cliCore.CLIDisplay.value("Favicon File", nodeOptions.favIconFile);
-        }
-        nodeOptions.envPrefix ??= "TWIN_NODE_";
-        cliCore.CLIDisplay.value("Environment Variable Prefix", nodeOptions.envPrefix);
-        overrideModuleImport(nodeOptions.executionDirectory ?? "");
-        const { nodeEngineConfig, nodeEnvVars: envVars } = await buildConfiguration(
-        // This is the only location in the code base that should access process.env directly
-        // So we can safely disable the linting rule here.
-        // eslint-disable-next-line no-restricted-syntax
-        process.env, nodeOptions, serverInfo);
-        cliCore.CLIDisplay.break();
-        const startResult = await start(nodeOptions, nodeEngineConfig, envVars);
-        if (!core.Is.empty(startResult)) {
-            for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
-                process.on(signal, async () => {
-                    cliCore.CLIDisplay.value("Terminate Signal", signal);
-                    await startResult.shutdown();
-                });
-            }
-        }
-    }
-    catch (err) {
-        cliCore.CLIDisplay.error(err);
-        // eslint-disable-next-line unicorn/no-process-exit
-        process.exit(1);
-    }
-}
-/**
- * Build the configuration for the TWIN Node server.
- * @param processEnv The environment variables from the process.
- * @param options The options for running the server.
- * @param serverInfo The server information.
- * @returns A promise that resolves to the engine server configuration, environment prefix, environment variables,
- * and options.
- */
-async function buildConfiguration(processEnv, options, serverInfo) {
-    let defaultEnvOnly = false;
-    if (core.Is.empty(options?.envFilenames)) {
-        const envFile = path.resolve(path.join(options.executionDirectory ?? "", ".env"));
-        cliCore.CLIDisplay.value("Default Environment File", envFile);
-        options ??= {};
-        options.envFilenames = [envFile];
-        defaultEnvOnly = true;
-    }
-    if (core.Is.arrayValue(options?.envFilenames)) {
-        const output = dotenv__namespace.config({
-            path: options?.envFilenames,
-            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.
-        if (!defaultEnvOnly && output.error) {
-            throw output.error;
-        }
-        if (core.Is.objectValue(output.parsed)) {
-            Object.assign(processEnv, output.parsed);
-        }
-    }
-    const envVars = core.EnvHelper.envToJson(processEnv, options.envPrefix ?? "");
-    // Expand any environment variables that use the @file: syntax
-    const keys = Object.keys(envVars);
-    for (const key of keys) {
-        if (core.Is.stringValue(envVars[key]) &&
-            (envVars[key].startsWith("@text:") || envVars[key].startsWith("@json:"))) {
-            const filePath = envVars[key].slice(6).trim();
-            const embeddedFile = path.resolve(path.join(options.executionDirectory ?? "", filePath));
-            if (envVars[key].startsWith("@text:")) {
-                cliCore.CLIDisplay.value(`Expanding Environment Variable: ${key} from text file`, embeddedFile);
-                envVars[key] = await loadTextFile(embeddedFile);
-            }
-            else if (envVars[key].startsWith("@json:")) {
-                cliCore.CLIDisplay.value(`Expanding Environment Variable: ${key} from JSON file`, embeddedFile);
-                envVars[key] = await loadJsonFile(embeddedFile);
-            }
-        }
-    }
-    // Extend the environment variables with any additional custom configuration.
-    if (core.Is.function(options?.extendEnvVars)) {
-        cliCore.CLIDisplay.task("Extending Environment Variables");
-        await options.extendEnvVars(envVars);
-    }
-    // Build the engine configuration from the environment variables.
-    const coreConfig = await buildEngineConfiguration(envVars);
-    const engineServerConfig = await buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile, options?.favIconFile);
-    // Merge any custom configuration provided in the options.
-    if (core.Is.arrayValue(options?.configFilenames)) {
-        for (const configFile of options.configFilenames) {
-            cliCore.CLIDisplay.value("Loading Configuration File", configFile);
-            const configFilePath = path.resolve(path.join(options.executionDirectory ?? "", configFile));
-            const config = await loadJsonFile(configFilePath);
-            Object.assign(engineServerConfig, config);
-        }
-    }
-    if (core.Is.objectValue(options?.config)) {
-        cliCore.CLIDisplay.task("Merging Custom Configuration");
-        Object.assign(engineServerConfig, options.config);
-    }
-    // Merge any custom configuration provided in the options.
-    if (core.Is.function(options?.extendConfig)) {
-        cliCore.CLIDisplay.task("Extending Configuration");
-        await options.extendConfig(envVars, engineServerConfig);
-    }
-    const nodeEngineConfig = await extensionsConfiguration(envVars, engineServerConfig);
-    return { nodeEngineConfig, nodeEnvVars: envVars };
-}
-/**
- * Override module imports to use local files where possible.
- * @param executionDirectory The execution directory for resolving local module paths.
- */
-function overrideModuleImport(executionDirectory) {
-    modules.ModuleHelper.overrideImport(async (moduleName) => {
-        if (moduleCache[moduleName]) {
-            return {
-                module: moduleCache[moduleName],
-                useDefault: false
-            };
-        }
-        // If the module path for example when dynamically loading
-        // modules looks like a local file then we try to resolve
-        // using the local file system
-        const isLocal = modules.ModuleHelper.isLocalModule(moduleName);
-        if (isLocal) {
-            // See if we can just resolve the filename locally
-            let localFilename = path.resolve(moduleName);
-            let exists = await fileExists(localFilename);
-            if (!exists) {
-                // Doesn't exist in the current directory, try the execution directory
-                localFilename = path.resolve(executionDirectory, moduleName);
-                exists = await fileExists(localFilename);
-            }
-            if (exists) {
-                // If the module exists then we can load it, otherwise
-                // we fallback to regular handling to see if that can import it
-                const module = await import(process.platform === "win32" ? `file://${localFilename}` : localFilename);
-                moduleCache[moduleName] = module;
-                return {
-                    module,
-                    useDefault: false
-                };
-            }
-        }
-        try {
-            // Try and load from node_modules manually
-            // This is needed for some environments where
-            // the module resolution doesn't work as expected
-            const npmRoot = node_child_process.execSync("npm root").toString().trim().replace(/\\/g, "/");
-            const packageJson = await loadJsonFile(path.resolve(npmRoot, moduleName, "package.json"));
-            const mainFile = packageJson?.module ?? packageJson?.main ?? "index.js";
-            const modulePath = path.resolve(npmRoot, moduleName, mainFile);
-            const exists = await fileExists(modulePath);
-            if (exists) {
-                const module = await import(process.platform === "win32" ? `file://${modulePath}` : modulePath);
-                moduleCache[moduleName] = module;
-                return {
-                    module,
-                    useDefault: false
-                };
-            }
-        }
-        catch {
-            // We just fallback to default handling if not possible
-        }
-        // We don't appear to be able to manually resolve this module
-        // So we let the default handling take care of it
-        // This will allow built-in modules and regular node_modules to load as normal
-        return {
-            useDefault: true
-        };
-    });
-}
-
-exports.ATTESTATION_VERIFICATION_METHOD_ID = ATTESTATION_VERIFICATION_METHOD_ID;
-exports.AUTH_SIGNING_KEY_ID = AUTH_SIGNING_KEY_ID;
-exports.BLOB_STORAGE_ENCRYPTION_KEY_ID = BLOB_STORAGE_ENCRYPTION_KEY_ID;
-exports.IMMUTABLE_PROOF_VERIFICATION_METHOD_ID = IMMUTABLE_PROOF_VERIFICATION_METHOD_ID;
-exports.NodeFeatures = NodeFeatures;
-exports.SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID = SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID;
-exports.VC_AUTHENTICATION_VERIFICATION_METHOD_ID = VC_AUTHENTICATION_VERIFICATION_METHOD_ID;
-exports.bootstrap = bootstrap;
-exports.bootstrapAuth = bootstrapAuth;
-exports.bootstrapBlobEncryption = bootstrapBlobEncryption;
-exports.bootstrapImmutableProofMethod = bootstrapImmutableProofMethod;
-exports.bootstrapNodeIdentity = bootstrapNodeIdentity;
-exports.bootstrapNodeUser = bootstrapNodeUser;
-exports.bootstrapSynchronisedStorage = bootstrapSynchronisedStorage;
-exports.buildConfiguration = buildConfiguration;
-exports.buildEngineConfiguration = buildEngineConfiguration;
-exports.buildEngineServerConfiguration = buildEngineServerConfiguration;
-exports.directoryExists = directoryExists;
-exports.extensionsConfiguration = extensionsConfiguration;
-exports.extensionsInitialiseEngine = extensionsInitialiseEngine;
-exports.extensionsInitialiseEngineServer = extensionsInitialiseEngineServer;
-exports.fileExists = fileExists;
-exports.getExecutionDirectory = getExecutionDirectory;
-exports.getFeatures = getFeatures;
-exports.getFiles = getFiles;
-exports.getSubFolders = getSubFolders;
-exports.initialiseLocales = initialiseLocales;
-exports.loadJsonFile = loadJsonFile;
-exports.loadTextFile = loadTextFile;
-exports.overrideModuleImport = overrideModuleImport;
-exports.run = run;
-exports.shutdownExtensions = shutdownExtensions;
-exports.start = start;