@twin.org/node-core 0.0.3-next.9 → 0.9.0

package/dist/es/builders/engineEnvBuilder.js

@@ -1,17 +1,17 @@
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 import path from "node:path";
-import { Coerce, Is } from "@twin.org/core";
-import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AuthenticationGeneratorComponentType, BackgroundTaskComponentType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataProcessingComponentType, DataSpaceConnectorComponentType, DltConfigType, DocumentManagementComponentType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, NftComponentType, NftConnectorType, RightsManagementDapComponentType, RightsManagementDarpComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, SynchronisedStorageComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TrustComponentType, VaultConnectorType, VerifiableStorageComponentType, VerifiableStorageConnectorType, WalletConnectorType } from "@twin.org/engine-types";
-import { DataAccessPointRestClient, PolicyNegotiationPointRestClient } from "@twin.org/rights-management-rest-client";
-import { ATTESTATION_VERIFICATION_METHOD_ID, BLOB_STORAGE_ENCRYPTION_KEY_ID, CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT, IMMUTABLE_PROOF_VERIFICATION_METHOD_ID, SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID, VC_AUTHENTICATION_VERIFICATION_METHOD_ID } from "../defaults.js";
+import { Coerce, Is, Mutex } from "@twin.org/core";
+import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AutomationComponentType, BackgroundTaskComponentType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataProcessingComponentType, DataspaceControlPlaneComponentType, DataspaceDataPlaneComponentType, DltConfigType, DocumentManagementComponentType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, HealthComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, MetricsCollectorComponentType, MetricsProducerComponentType, NftComponentType, NftConnectorType, NotarizationComponentType, NotarizationConnectorType, PlatformComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TrustComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
+import { OpenTelemetryReaderTypes } from "@twin.org/telemetry-connector-opentelemetry";
+import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT } from "../defaults.js";
+import { isAuthEntityStorageRequired } from "./engineServerEnvBuilder.js";
 /**
  * Build the engine core configuration from environment variables.
  * @param envVars The environment variables.
- * @param contextIdKeys The context ID keys.
  * @returns The config for the core.
  */
-export async function buildEngineConfiguration(envVars, contextIdKeys) {
+export async function buildEngineConfiguration(envVars) {
     if (Is.stringValue(envVars.storageFileRoot)) {
         envVars.stateFilename ??= "engine-state.json";
         envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
@@ -19,8 +19,15 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
     }
     const coreConfig = {
         debug: Coerce.boolean(envVars.debug) ?? false,
+        silent: Coerce.boolean(envVars.silent) ?? false,
+        silentLoggers: commaSeparatedListToArray(envVars.loggingSilentComponents),
         types: {}
     };
+    const mutexTimeoutMs = Coerce.integer(envVars.mutexTimeoutMsDefault);
+    if (!Is.empty(mutexTimeoutMs)) {
+        Mutex.setDefaultTimeoutMs(mutexTimeoutMs);
+    }
+    await configurePlatform(coreConfig, envVars);
     await configureTenant(coreConfig, envVars);
     await configureContextIdHandlers(coreConfig, envVars);
     await configureEntityStorage(coreConfig, envVars);
@@ -32,11 +39,15 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
     await configureTaskScheduler(coreConfig, envVars);
     await configureEventBus(coreConfig, envVars);
     await configureTelemetry(coreConfig, envVars);
+    await configureMetricsCollector(coreConfig, envVars);
     await configureMessaging(coreConfig, envVars);
+    await configureAutomation(coreConfig, envVars);
+    await configureHealth(coreConfig, envVars);
     await configureFaucet(coreConfig, envVars);
     await configureWallet(coreConfig, envVars);
     await configureNft(coreConfig, envVars);
-    await configureVerifiableStorage(coreConfig, envVars);
+    await configureNotarization(coreConfig, envVars);
+    await configureImmutableProof(coreConfig, envVars);
     await configureIdentity(coreConfig, envVars);
     await configureIdentityResolver(coreConfig, envVars);
     await configureIdentityProfile(coreConfig, envVars);
@@ -45,18 +56,17 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
     await configureAuditableItemGraph(coreConfig, envVars);
     await configureAuditableItemStream(coreConfig, envVars);
     await configureDocumentManagement(coreConfig, envVars);
-    await configureVerifiableCredentialAuthentication(coreConfig, envVars);
     await configureTrust(coreConfig, envVars);
     await configureRightsManagement(coreConfig, envVars);
-    await configureSynchronisedStorage(coreConfig, envVars);
     await configureFederatedCatalogue(coreConfig, envVars);
-    await configureDataSpaceConnector(coreConfig, envVars);
+    await configureDataspace(coreConfig, envVars);
     return coreConfig;
 }
 /**
  * Configures the entity storage.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the entity storage configuration has been applied.
  */
 async function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
@@ -64,14 +74,22 @@ async function configureEntityStorage(coreConfig, envVars) {
     const entityStorageConnectorTypes = commaSeparatedListToArray(envVars.entityStorageConnectorType);
     if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Memory)) {
         coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.Memory
+            type: EntityStorageConnectorType.Memory,
+            options: {
+                config: {
+                    mutexTimeoutMs: Coerce.integer(envVars.entityStorageMemoryMutexTimeout)
+                }
+            }
         });
     }
     if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.File)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.File,
             options: {
-                config: { directory: envVars.storageFileRoot ?? "" },
+                config: {
+                    directory: envVars.storageFileRoot ?? "",
+                    mutexTimeoutMs: Coerce.integer(envVars.entityStorageFileMutexTimeout)
+                },
                 folderPrefix: envVars.entityStorageTablePrefix
             }
         });
@@ -86,7 +104,7 @@ async function configureEntityStorage(coreConfig, envVars) {
                     accessKeyId: envVars.awsDynamodbAccessKeyId,
                     secretAccessKey: envVars.awsDynamodbSecretAccessKey,
                     endpoint: envVars.awsDynamodbEndpoint,
-                    connectionTimeoutMs: Coerce.integer(envVars.awsDynamodbConnectionTimeoutMs)
+                    connectionTimeoutMs: Coerce.integer(envVars.awsDynamodbConnectionTimeout)
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -115,7 +133,7 @@ async function configureEntityStorage(coreConfig, envVars) {
                     credentials: envVars.gcpFirestoreCredentials ?? "",
                     databaseId: envVars.gcpFirestoreDatabaseId ?? "",
                     collectionName: envVars.gcpFirestoreCollectionName ?? "",
-                    endpoint: envVars.gcpFirestoreApiEndpoint ?? ""
+                    endpoint: envVars.gcpFirestoreEndpoint ?? ""
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -181,15 +199,6 @@ async function configureEntityStorage(coreConfig, envVars) {
         });
     }
     const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Synchronised)) {
-        // For synchronised storage we use the default connector as the one we wrap for real DB operations
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.Synchronised,
-            options: {
-                entityStorageConnectorType: defaultEntityStorageConnectorType
-            }
-        });
-    }
     if (Is.arrayValue(entityStorageConnectorTypes)) {
         for (const config of coreConfig.types.entityStorageConnector) {
             if (config.type === defaultEntityStorageConnectorType) {
@@ -203,6 +212,7 @@ async function configureEntityStorage(coreConfig, envVars) {
  * Configures the blob storage.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the blob storage configuration has been applied.
  */
 async function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
@@ -274,7 +284,7 @@ async function configureBlobStorage(coreConfig, envVars) {
                     projectId: envVars.gcpStorageProjectId ?? "",
                     credentials: envVars.gcpStorageCredentials ?? "",
                     bucketName: envVars.gcpStorageBucketName ?? "",
-                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
+                    apiEndpoint: envVars.gcpFirestoreEndpoint
                 },
                 storagePrefix: envVars.blobStoragePrefix
             }
@@ -286,14 +296,6 @@ async function configureBlobStorage(coreConfig, envVars) {
             if (config.type === defaultStorageConnectorType) {
                 config.isDefault = true;
             }
-            // If this blob storage connector is the one to use for public access
-            // then add it as a feature
-            if (Is.stringValue(envVars.blobStorageConnectorPublic) &&
-                config.type === envVars.blobStorageConnectorPublic) {
-                config.features ??= [];
-                config.features.push("public");
-                break;
-            }
         }
     }
     if (coreConfig.types.blobStorageConnector.length > 0) {
@@ -303,7 +305,7 @@ async function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? (envVars.blobStorageEncryptionKeyId ?? BLOB_STORAGE_ENCRYPTION_KEY_ID)
+                        ? envVars.blobStorageEncryptionKeyId
                         : undefined
                 }
             }
@@ -314,6 +316,7 @@ async function configureBlobStorage(coreConfig, envVars) {
  * Configures the logging.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the logging configuration has been applied.
  */
 async function configureLogging(coreConfig, envVars) {
     coreConfig.types.loggingConnector ??= [];
@@ -334,7 +337,14 @@ async function configureLogging(coreConfig, envVars) {
         }
         else if (loggingConnector === LoggingConnectorType.EntityStorage) {
             coreConfig.types.loggingConnector.push({
-                type: LoggingConnectorType.EntityStorage
+                type: LoggingConnectorType.EntityStorage,
+                options: {
+                    config: {
+                        batchSize: Coerce.integer(envVars.loggingBatchSize),
+                        batchIntervalMs: (Coerce.integer(envVars.loggingBatchFlushInterval) ?? 5) * 1000,
+                        mutexTimeoutMs: Coerce.integer(envVars.loggingMutexTimeout)
+                    }
+                }
             });
             additionalConnectorCount++;
         }
@@ -366,12 +376,18 @@ async function configureLogging(coreConfig, envVars) {
  * Configures the vault.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the vault configuration has been applied.
  */
 async function configureVault(coreConfig, envVars) {
     coreConfig.types.vaultConnector ??= [];
     if (envVars.vaultConnector === VaultConnectorType.EntityStorage) {
         coreConfig.types.vaultConnector.push({
-            type: VaultConnectorType.EntityStorage
+            type: VaultConnectorType.EntityStorage,
+            options: {
+                config: {
+                    prefix: envVars.vaultPrefix
+                }
+            }
         });
     }
     else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
@@ -380,7 +396,8 @@ async function configureVault(coreConfig, envVars) {
             options: {
                 config: {
                     endpoint: envVars.hashicorpVaultEndpoint ?? "",
-                    token: envVars.hashicorpVaultToken ?? ""
+                    token: envVars.hashicorpVaultToken ?? "",
+                    prefix: envVars.vaultPrefix
                 }
             }
         });
@@ -390,19 +407,21 @@ async function configureVault(coreConfig, envVars) {
  * Configures the background task.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the background task configuration has been applied.
  */
 async function configureBackgroundTask(coreConfig, envVars) {
     coreConfig.types.backgroundTaskComponent ??= [];
-    if (Coerce.boolean(envVars.backgroundTasksEnabled) ?? false) {
+    if (isBackgroundTasksRequired(envVars)) {
         coreConfig.types.backgroundTaskComponent.push({
             type: BackgroundTaskComponentType.Service
         });
     }
 }
 /**
- * Configures the event bud.
+ * Configures the event bus.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the event bus configuration has been applied.
  */
 async function configureEventBus(coreConfig, envVars) {
     coreConfig.types.eventBusConnector ??= [];
@@ -420,6 +439,7 @@ async function configureEventBus(coreConfig, envVars) {
  * Configures the telemetry.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the telemetry configuration has been applied.
  */
 async function configureTelemetry(coreConfig, envVars) {
     coreConfig.types.telemetryConnector ??= [];
@@ -428,30 +448,140 @@ async function configureTelemetry(coreConfig, envVars) {
             type: TelemetryConnectorType.EntityStorage
         });
     }
+    else if (envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
+        let readers;
+        if (envVars.openTelemetryReader === "prometheus") {
+            readers = {
+                prometheus: {
+                    type: OpenTelemetryReaderTypes.Prometheus,
+                    port: Coerce.integer(envVars.openTelemetryPrometheusPort)
+                }
+            };
+        }
+        coreConfig.types.telemetryConnector.push({
+            type: TelemetryConnectorType.OpenTelemetry,
+            options: {
+                config: {
+                    meterName: envVars.openTelemetryMeterName,
+                    meterVersion: envVars.openTelemetryMeterVersion,
+                    readers
+                }
+            }
+        });
+    }
     if (coreConfig.types.telemetryConnector.length > 0) {
         coreConfig.types.telemetryComponent ??= [];
         coreConfig.types.telemetryComponent.push({ type: TelemetryComponentType.Service });
     }
 }
+/**
+ * Configures the metrics producers and orchestrator service.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the metrics collector configuration has been applied.
+ */
+async function configureMetricsCollector(coreConfig, envVars) {
+    if (isTelemetryRequired(envVars)) {
+        const intervalSec = Coerce.integer(envVars.telemetryMetricsCollectorInterval) ?? 60;
+        coreConfig.types.metricsCollectorComponent ??= [];
+        coreConfig.types.metricsCollectorComponent.push({
+            type: MetricsCollectorComponentType.Service,
+            options: { config: { intervalMs: intervalSec * 1000 } }
+        });
+        const maxHistory = Coerce.integer(envVars.telemetryMetricsProducerMaxHistory) ?? 1440;
+        coreConfig.types.metricsProducerComponent ??= [];
+        const metricsProducers = commaSeparatedListToArray(envVars.telemetryMetricsProducers ??
+            [MetricsProducerComponentType.System, MetricsProducerComponentType.Process].join(","));
+        for (const producerType of metricsProducers) {
+            coreConfig.types.metricsProducerComponent.push({
+                type: producerType,
+                options: { maxHistory }
+            });
+        }
+    }
+}
+/**
+ * Configures the automation.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the automation configuration has been applied.
+ */
+async function configureAutomation(coreConfig, envVars) {
+    coreConfig.types.automationComponent ??= [];
+    if (isAutomationRequired(envVars)) {
+        coreConfig.types.automationComponent.push({
+            type: AutomationComponentType.Service
+        });
+        const automationActionTypes = commaSeparatedListToArray(envVars.automationActionTypes);
+        if (Is.arrayValue(automationActionTypes)) {
+            coreConfig.types.automationAction ??= [];
+            for (const actionType of automationActionTypes) {
+                coreConfig.types.automationAction.push({
+                    type: actionType,
+                    isMultiInstance: true
+                });
+            }
+        }
+    }
+}
+/**
+ * Configures the health.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the health configuration has been applied.
+ */
+async function configureHealth(coreConfig, envVars) {
+    coreConfig.types.healthComponent ??= [];
+    if (Coerce.boolean(envVars.healthEnabled) ?? false) {
+        coreConfig.types.healthComponent.push({
+            type: HealthComponentType.Service,
+            options: {
+                config: {
+                    healthCheckInterval: (Coerce.integer(envVars.healthInterval) ?? 60) * 1000,
+                    initialInterval: (Coerce.integer(envVars.healthStartupInterval) ?? 2) * 1000
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the platform.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the platform configuration has been applied.
+ */
+async function configurePlatform(coreConfig, envVars) {
+    const isTenantEnabled = Coerce.boolean(envVars.tenantEnabled) ?? false;
+    coreConfig.types.platformComponent ??= [];
+    coreConfig.types.platformComponent.push({
+        type: PlatformComponentType.Service,
+        options: {
+            config: {
+                isMultiTenant: isTenantEnabled
+            }
+        }
+    });
+}
 /**
  * Configures the tenant.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the tenant configuration has been applied.
  */
 async function configureTenant(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.tenantEnabled) ?? false) {
+    const isTenantEnabled = Coerce.boolean(envVars.tenantEnabled) ?? false;
+    if (isTenantEnabled) {
         coreConfig.types.tenantAdminComponent ??= [];
         coreConfig.types.tenantAdminComponent.push({
             type: TenantAdminComponentType.Service
         });
-        coreConfig.types.tenantComponent ??= [];
-        coreConfig.types.tenantComponent.push({ type: TenantAdminComponentType.Service });
     }
 }
 /**
- * Configures the context id handlers.
+ * Configures the context ID handlers.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the context ID handler configuration has been applied.
  */
 async function configureContextIdHandlers(coreConfig, envVars) {
     coreConfig.types.contextIdHandlerComponent ??= [];
@@ -470,6 +600,7 @@ async function configureContextIdHandlers(coreConfig, envVars) {
  * Configures the messaging.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the messaging configuration has been applied.
  */
 async function configureMessaging(coreConfig, envVars) {
     if (Coerce.boolean(envVars.messagingEnabled) ?? false) {
@@ -521,6 +652,16 @@ async function configureMessaging(coreConfig, envVars) {
             });
         }
         else if (envVars.messagingPushNotificationConnector === MessagingPushNotificationConnectorType.Aws) {
+            let messagingApps;
+            if (Is.stringValue(envVars.awsMessagingPushNotificationApplications)) {
+                try {
+                    messagingApps = JSON.parse(envVars.awsMessagingPushNotificationApplications);
+                }
+                catch { }
+            }
+            else if (Is.array(envVars.awsMessagingPushNotificationApplications)) {
+                messagingApps = envVars.awsMessagingPushNotificationApplications;
+            }
             coreConfig.types.messagingPushNotificationConnector.push({
                 type: MessagingPushNotificationConnectorType.Aws,
                 options: {
@@ -530,9 +671,7 @@ async function configureMessaging(coreConfig, envVars) {
                         accessKeyId: envVars.awsSesAccessKeyId,
                         secretAccessKey: envVars.awsSesSecretAccessKey,
                         endpoint: envVars.awsSesEndpoint,
-                        applicationsSettings: Is.json(envVars.awsMessagingPushNotificationApplications)
-                            ? JSON.parse(envVars.awsMessagingPushNotificationApplications)
-                            : []
+                        applicationsSettings: messagingApps ?? []
                     }
                 }
             });
@@ -549,6 +688,7 @@ async function configureMessaging(coreConfig, envVars) {
  * Configures the faucet.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the faucet configuration has been applied.
  */
 async function configureFaucet(coreConfig, envVars) {
     coreConfig.types.faucetConnector ??= [];
@@ -575,6 +715,7 @@ async function configureFaucet(coreConfig, envVars) {
  * Configures the wallet.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the wallet configuration has been applied.
  */
 async function configureWallet(coreConfig, envVars) {
     coreConfig.types.walletConnector ??= [];
@@ -597,6 +738,7 @@ async function configureWallet(coreConfig, envVars) {
  * Configures the NFT.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the NFT configuration has been applied.
  */
 async function configureNft(coreConfig, envVars) {
     coreConfig.types.nftConnector ??= [];
@@ -607,10 +749,14 @@ async function configureNft(coreConfig, envVars) {
     }
     else if (envVars.nftConnector === NftConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
+        const config = {
+            ...dltConfig?.options?.config,
+            deploymentPkgId: Is.stringValue(envVars.nftPackageId) ? envVars.nftPackageId : undefined
+        };
         coreConfig.types.nftConnector.push({
             type: NftConnectorType.Iota,
             options: {
-                config: dltConfig?.options?.config ?? {}
+                config
             }
         });
     }
@@ -620,37 +766,46 @@ async function configureNft(coreConfig, envVars) {
     }
 }
 /**
- * Configures the verifiable storage.
+ * Configures the notarization.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the notarization configuration has been applied.
  */
-async function configureVerifiableStorage(coreConfig, envVars) {
-    coreConfig.types.verifiableStorageConnector ??= [];
-    if (envVars.verifiableStorageConnector === VerifiableStorageConnectorType.EntityStorage) {
-        coreConfig.types.verifiableStorageConnector.push({
-            type: VerifiableStorageConnectorType.EntityStorage
+async function configureNotarization(coreConfig, envVars) {
+    coreConfig.types.notarizationConnector ??= [];
+    if (envVars.notarizationConnector === NotarizationConnectorType.EntityStorage) {
+        coreConfig.types.notarizationConnector.push({
+            type: NotarizationConnectorType.EntityStorage
         });
     }
-    else if (envVars.verifiableStorageConnector === VerifiableStorageConnectorType.Iota) {
+    else if (envVars.notarizationConnector === NotarizationConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
-        coreConfig.types.verifiableStorageConnector.push({
-            type: VerifiableStorageConnectorType.Iota,
+        coreConfig.types.notarizationConnector.push({
+            type: NotarizationConnectorType.Iota,
             options: {
                 config: dltConfig?.options?.config ?? {}
             }
         });
     }
-    if (coreConfig.types.verifiableStorageConnector.length > 0) {
-        coreConfig.types.verifiableStorageComponent ??= [];
-        coreConfig.types.verifiableStorageComponent.push({
-            type: VerifiableStorageComponentType.Service
-        });
+    if (coreConfig.types.notarizationConnector.length > 0) {
+        coreConfig.types.notarizationComponent ??= [];
+        coreConfig.types.notarizationComponent.push({ type: NotarizationComponentType.Service });
+    }
+}
+/**
+ * Configures the immutable proof.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the immutable proof configuration has been applied.
+ */
+async function configureImmutableProof(coreConfig, envVars) {
+    if (isImmutableProofRequired(envVars)) {
         coreConfig.types.immutableProofComponent ??= [];
         coreConfig.types.immutableProofComponent.push({
             type: ImmutableProofComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.immutableProofVerificationMethodId ?? IMMUTABLE_PROOF_VERIFICATION_METHOD_ID
+                    verificationMethodId: envVars.immutableProofVerificationMethodId
                 }
             }
         });
@@ -660,6 +815,7 @@ async function configureVerifiableStorage(coreConfig, envVars) {
  * Configures the identity.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the identity configuration has been applied.
  */
 async function configureIdentity(coreConfig, envVars) {
     coreConfig.types.identityConnector ??= [];
@@ -673,7 +829,13 @@ async function configureIdentity(coreConfig, envVars) {
         coreConfig.types.identityConnector.push({
             type: IdentityConnectorType.Iota,
             options: {
-                config: dltConfig?.options?.config ?? {}
+                config: {
+                    ...(dltConfig?.options?.config ?? {}),
+                    identityPkgId: Is.stringValue(envVars.iotaIdentityPackageId)
+                        ? envVars.iotaIdentityPackageId
+                        : undefined,
+                    walletAddressIndex: Coerce.integer(envVars.identityWalletAddressIndex) ?? 0
+                }
             }
         });
     }
@@ -686,6 +848,7 @@ async function configureIdentity(coreConfig, envVars) {
  * Configures the identity resolver.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the identity resolver configuration has been applied.
  */
 async function configureIdentityResolver(coreConfig, envVars) {
     coreConfig.types.identityResolverConnector ??= [];
@@ -699,7 +862,12 @@ async function configureIdentityResolver(coreConfig, envVars) {
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.Iota,
             options: {
-                config: dltConfig?.options?.config ?? {}
+                config: {
+                    ...dltConfig?.options?.config,
+                    identityPkgId: Is.stringValue(envVars.iotaIdentityPackageId)
+                        ? envVars.iotaIdentityPackageId
+                        : undefined
+                }
             }
         });
     }
@@ -724,6 +892,7 @@ async function configureIdentityResolver(coreConfig, envVars) {
  * Configures the identity profile.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the identity profile configuration has been applied.
  */
 async function configureIdentityProfile(coreConfig, envVars) {
     coreConfig.types.identityProfileConnector ??= [];
@@ -741,6 +910,7 @@ async function configureIdentityProfile(coreConfig, envVars) {
  * Configures the attestation.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the attestation configuration has been applied.
  */
 async function configureAttestation(coreConfig, envVars) {
     coreConfig.types.attestationConnector ??= [];
@@ -755,7 +925,7 @@ async function configureAttestation(coreConfig, envVars) {
             type: AttestationComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.attestationVerificationMethodId ?? ATTESTATION_VERIFICATION_METHOD_ID
+                    verificationMethodId: envVars.attestationVerificationMethodId
                 }
             }
         });
@@ -765,12 +935,18 @@ async function configureAttestation(coreConfig, envVars) {
  * Configures the auditable item graph.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the auditable item graph configuration has been applied.
  */
 async function configureAuditableItemGraph(coreConfig, envVars) {
     if (Coerce.boolean(envVars.auditableItemGraphEnabled) ?? false) {
         coreConfig.types.auditableItemGraphComponent ??= [];
         coreConfig.types.auditableItemGraphComponent.push({
-            type: AuditableItemGraphComponentType.Service
+            type: AuditableItemGraphComponentType.Service,
+            options: {
+                config: {
+                    mutexTimeoutMs: Coerce.integer(envVars.auditableItemGraphMutexTimeout)
+                }
+            }
         });
     }
 }
@@ -778,12 +954,18 @@ async function configureAuditableItemGraph(coreConfig, envVars) {
  * Configures the auditable item stream.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the auditable item stream configuration has been applied.
  */
 async function configureAuditableItemStream(coreConfig, envVars) {
     if (Coerce.boolean(envVars.auditableItemStreamEnabled) ?? false) {
         coreConfig.types.auditableItemStreamComponent ??= [];
         coreConfig.types.auditableItemStreamComponent.push({
-            type: AuditableItemStreamComponentType.Service
+            type: AuditableItemStreamComponentType.Service,
+            options: {
+                config: {
+                    mutexTimeoutMs: Coerce.integer(envVars.auditableItemStreamMutexTimeout)
+                }
+            }
         });
     }
 }
@@ -791,6 +973,7 @@ async function configureAuditableItemStream(coreConfig, envVars) {
  * Configures the data processing.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the data processing configuration has been applied.
  */
 async function configureDataProcessing(coreConfig, envVars) {
     if (Coerce.boolean(envVars.dataProcessingEnabled) ?? false) {
@@ -816,32 +999,18 @@ async function configureDataProcessing(coreConfig, envVars) {
  * Configures the document management.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the document management configuration has been applied.
  */
 async function configureDocumentManagement(coreConfig, envVars) {
     if (Coerce.boolean(envVars.documentManagementEnabled) ?? false) {
         coreConfig.types.documentManagementComponent ??= [];
         coreConfig.types.documentManagementComponent.push({
-            type: DocumentManagementComponentType.Service
-        });
-    }
-}
-/**
- * Configures the verifiable credential authentication.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureVerifiableCredentialAuthentication(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
-        // Can only perform VC authentication if identity component is available
-        coreConfig.types.authenticationGeneratorComponent ??= [];
-        coreConfig.types.authenticationGeneratorComponent.push({
-            type: AuthenticationGeneratorComponentType.VerifiableCredential,
+            type: DocumentManagementComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.vcAuthenticationVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID
+                    mutexTimeoutMs: Coerce.integer(envVars.documentManagementMutexTimeout)
                 }
-            },
-            features: ["verifiable-credential"]
+            }
         });
     }
 }
@@ -849,9 +1018,10 @@ async function configureVerifiableCredentialAuthentication(coreConfig, envVars)
  * Configures the trust components.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the trust configuration has been applied.
  */
 async function configureTrust(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.trustEnabled) ?? false) {
+    if (isTrustRequired(envVars)) {
         coreConfig.types.trustComponent ??= [];
         coreConfig.types.trustComponent.push({
             type: TrustComponentType.Service
@@ -863,7 +1033,8 @@ async function configureTrust(coreConfig, envVars) {
                 type: trustGeneratorType,
                 options: {
                     config: {
-                        verificationMethodId: envVars.trustVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID
+                        verificationMethodId: envVars.trustVerificationMethodId ?? "",
+                        tokenTtlInSeconds: Coerce.integer(envVars.trustJwtTtl)
                     }
                 }
             });
@@ -871,9 +1042,23 @@ async function configureTrust(coreConfig, envVars) {
         coreConfig.types.trustVerifierComponent ??= [];
         const trustVerifierTypes = commaSeparatedListToArray(envVars.trustVerifiers);
         for (const trustVerifierType of trustVerifierTypes) {
-            coreConfig.types.trustVerifierComponent.push({
-                type: trustVerifierType
-            });
+            const type = trustVerifierType;
+            if (type === TrustVerifierComponentType.IdentityAllowDeny) {
+                coreConfig.types.trustVerifierComponent.push({
+                    type,
+                    options: {
+                        config: {
+                            allowIdentities: commaSeparatedListToArray(envVars.trustIdentitiesAllow),
+                            denyIdentities: commaSeparatedListToArray(envVars.trustIdentitiesDeny)
+                        }
+                    }
+                });
+            }
+            else {
+                coreConfig.types.trustVerifierComponent.push({
+                    type
+                });
+            }
         }
     }
 }
@@ -881,9 +1066,10 @@ async function configureTrust(coreConfig, envVars) {
  * Configures the rights management.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the rights management configuration has been applied.
  */
 async function configureRightsManagement(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+    if (isRightsManagementRequired(envVars)) {
         coreConfig.types.rightsManagementPapComponent ??= [];
         coreConfig.types.rightsManagementPapComponent.push({
             type: RightsManagementPapComponentType.Service
@@ -909,39 +1095,44 @@ async function configureRightsManagement(coreConfig, envVars) {
             type: RightsManagementPepComponentType.Service
         });
         coreConfig.types.rightsManagementPnpComponent ??= [];
+        // Single source of truth for the rights-management mount path.
+        const rightsManagementPath = envVars.rightsManagementCallbackPath ?? "rights-management";
+        // We add a multi instance REST client for the remote negotiations
+        // use a dummy endpoint for now as the actual endpoint will be provided in the config
+        // of the policy negotiator when it is used for remote negotiations
+        // We must add it before the service as the service needs to be able to request
+        // the REST client type from the engine core to be able to support remote negotiations
+        coreConfig.types.rightsManagementPnpComponent.push({
+            type: RightsManagementPnpComponentType.RestClient,
+            options: {
+                // The endpoint is required in config, but as this is multi-instance
+                // the actual endpoint will be provided in the config when it is constructed
+                endpoint: "http://localhost",
+                pathPrefix: rightsManagementPath
+            },
+            isMultiInstance: true,
+            features: ["remote"]
+        });
         coreConfig.types.rightsManagementPnpComponent.push({
             type: RightsManagementPnpComponentType.Service,
             options: {
                 config: {
-                    baseCallbackUrl: envVars.rightsManagementBaseCallbackUrl ?? "",
-                    negotiationComponentCreator: async (url) => new PolicyNegotiationPointRestClient({ endpoint: url })
+                    callbackPath: rightsManagementPath,
+                    includeErrorDetails: coreConfig.debug ?? false,
+                    mutexTimeoutMs: Coerce.integer(envVars.rightsManagementMutexTimeout)
                 }
-            }
+            },
+            isDefault: true
         });
         coreConfig.types.rightsManagementPnapComponent ??= [];
         coreConfig.types.rightsManagementPnapComponent.push({
-            type: RightsManagementPnapComponentType.Service
-        });
-        coreConfig.types.rightsManagementDapComponent ??= [];
-        coreConfig.types.rightsManagementDapComponent.push({
-            type: RightsManagementDapComponentType.Service
-        });
-        coreConfig.types.rightsManagementDarpComponent ??= [];
-        coreConfig.types.rightsManagementDarpComponent.push({
-            type: RightsManagementDarpComponentType.Service,
+            type: RightsManagementPnapComponentType.Service,
             options: {
                 config: {
-                    dataAccessComponentCreator: async (url) => new DataAccessPointRestClient({ endpoint: url })
+                    mutexTimeoutMs: Coerce.integer(envVars.rightsManagementMutexTimeout)
                 }
             }
         });
-        coreConfig.types.rightsManagementDataAccessHandlerComponent ??= [];
-        const dataAccessHandlerTypes = commaSeparatedListToArray(envVars.rightsManagementDataAccessHandlers);
-        for (const dataAccessHandlerType of dataAccessHandlerTypes) {
-            coreConfig.types.rightsManagementDataAccessHandlerComponent.push({
-                type: dataAccessHandlerType
-            });
-        }
         coreConfig.types.rightsManagementPolicyArbiterComponent ??= [];
         const policyArbiterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyArbiters);
         for (const policyArbiterType of policyArbiterTypes) {
@@ -949,6 +1140,13 @@ async function configureRightsManagement(coreConfig, envVars) {
                 type: policyArbiterType
             });
         }
+        coreConfig.types.rightsManagementPolicyObligationEnforcerComponent ??= [];
+        const policyObligationEnforcerTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyObligationEnforcers);
+        for (const policyObligationEnforcerType of policyObligationEnforcerTypes) {
+            coreConfig.types.rightsManagementPolicyObligationEnforcerComponent.push({
+                type: policyObligationEnforcerType
+            });
+        }
         coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent ??= [];
         const policyEnforcementProcessTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyEnforcementProcessors);
         for (const policyEnforcementProcessorType of policyEnforcementProcessTypes) {
@@ -990,94 +1188,105 @@ async function configureRightsManagement(coreConfig, envVars) {
  * Configures the task scheduler.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the task scheduler configuration has been applied.
  */
 async function configureTaskScheduler(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
+    if (isTaskSchedulerRequired(envVars)) {
         coreConfig.types.taskSchedulerComponent ??= [];
         coreConfig.types.taskSchedulerComponent.push({
             type: TaskSchedulerComponentType.Service
         });
     }
 }
-/**
- * Configures the synchronised storage.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-async function configureSynchronisedStorage(coreConfig, envVars) {
-    if (Is.arrayValue(coreConfig.types.identityResolverComponent) &&
-        (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false)) {
-        // Check if the config provides a custom verifiable storage key id
-        let verifiableStorageKeyId = Coerce.string(envVars.synchronisedStorageVerifiableStorageKeyId);
-        if (!Is.stringValue(verifiableStorageKeyId)) {
-            // No custom key so default to the network setting
-            verifiableStorageKeyId = envVars.iotaNetwork;
-        }
-        coreConfig.types.synchronisedStorageComponent ??= [];
-        coreConfig.types.synchronisedStorageComponent.push({
-            type: SynchronisedStorageComponentType.Service,
-            options: {
-                config: {
-                    verifiableStorageKeyId: verifiableStorageKeyId ?? "",
-                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId ??
-                        SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID,
-                    entityUpdateIntervalMinutes: Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
-                    consolidationIntervalMinutes: Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
-                    consolidationBatchSize: Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
-                    maxConsolidations: Coerce.number(envVars.synchronisedStorageMaxConsolidations)
-                }
-            }
-        });
-        // If there is a trusted url set, we need to add a client
-        // and give it a feature of trusted so that when the synchronised
-        // storage is created it can pickup the correct component
-        if (Is.stringValue(envVars.synchronisedStorageTrustedUrl)) {
-            coreConfig.types.synchronisedStorageComponent.push({
-                type: SynchronisedStorageComponentType.RestClient,
-                options: {
-                    endpoint: envVars.synchronisedStorageTrustedUrl
-                },
-                features: ["trusted"]
-            });
-        }
-    }
-}
 /**
  * Configures the federated catalogue.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the federated catalogue configuration has been applied.
  */
 async function configureFederatedCatalogue(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) {
+    if (isFederatedCatalogueRequired(envVars)) {
         coreConfig.types.federatedCatalogueComponent ??= [];
-        coreConfig.types.federatedCatalogueComponent.push({
-            type: FederatedCatalogueComponentType.Service,
-            options: {}
-        });
-        coreConfig.types.federatedCatalogueFilterComponent ??= [];
-        const filters = commaSeparatedListToArray(envVars.federatedCatalogueFilters);
-        for (const filter of filters) {
-            coreConfig.types.federatedCatalogueFilterComponent.push({
-                type: filter,
-                options: {}
+        if (Is.stringValue(envVars.federatedCatalogueRemoteEndpoint)) {
+            coreConfig.types.federatedCatalogueComponent.push({
+                type: FederatedCatalogueComponentType.RestClient,
+                options: {
+                    endpoint: envVars.federatedCatalogueRemoteEndpoint
+                }
             });
         }
+        else {
+            coreConfig.types.federatedCatalogueComponent.push({
+                type: FederatedCatalogueComponentType.Service,
+                options: {
+                    config: {
+                        mutexTimeoutMs: Coerce.integer(envVars.federatedCatalogueMutexTimeout)
+                    }
+                }
+            });
+            coreConfig.types.federatedCatalogueFilterComponent ??= [];
+            const filters = commaSeparatedListToArray(envVars.federatedCatalogueFilters);
+            for (const filter of filters) {
+                coreConfig.types.federatedCatalogueFilterComponent.push({
+                    type: filter,
+                    options: {}
+                });
+            }
+        }
     }
 }
 /**
- * Configures the data space connector.
+ * Configures the dataspace control plane and data plane.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the dataspace configuration has been applied.
  */
-async function configureDataSpaceConnector(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.dataSpaceConnectorEnabled) ?? false) {
-        coreConfig.types.dataSpaceConnectorComponent ??= [];
-        coreConfig.types.dataSpaceConnectorComponent.push({
-            type: DataSpaceConnectorComponentType.Service,
+async function configureDataspace(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.dataspaceEnabled) ?? false) {
+        coreConfig.types.dataspaceControlPlaneComponent ??= [];
+        // We add a multi instance REST client for remote/consumer-initiated transfers.
+        coreConfig.types.dataspaceControlPlaneComponent.push({
+            type: DataspaceControlPlaneComponentType.RestClient,
+            options: {
+                endpoint: "http://localhost"
+            },
+            isMultiInstance: true,
+            features: ["remote"]
+        });
+        const stalledNegotiationTimeout = Coerce.integer(envVars.dataspaceStalledNegotiationTimeout);
+        const stalledTransferTimeout = Coerce.integer(envVars.dataspaceStalledTransferTimeout);
+        coreConfig.types.dataspaceControlPlaneComponent.push({
+            type: DataspaceControlPlaneComponentType.Service,
             options: {
                 config: {
-                    retainActivityLogsFor: Coerce.number(envVars.dataSpaceConnectorRetainActivityLogsFor),
-                    activityLogsCleanUpInterval: Coerce.number(envVars.dataSpaceConnectorActivityLogsCleanUpInterval)
+                    // Must match the control-plane REST mount, as it is combined with the public origin
+                    // to build the consumer's advertised callback address;
+                    callbackPath: envVars.dataspaceCallbackPath ?? "dataspace-control-plane",
+                    dataPlanePath: envVars.dataspaceDataPlanePath,
+                    autoStartTransfers: Coerce.boolean(envVars.dataspaceAutoStartTransfers),
+                    stalledNegotiationTimeoutMs: !Is.empty(stalledNegotiationTimeout)
+                        ? stalledNegotiationTimeout * 1000
+                        : undefined,
+                    stalledTransferTimeoutMs: !Is.empty(stalledTransferTimeout)
+                        ? stalledTransferTimeout * 1000
+                        : undefined
+                }
+            },
+            isDefault: true
+        });
+        const retainActivityLogsFor = Coerce.integer(envVars.dataspaceRetainActivityLogsFor);
+        const activityLogsCleanUpInterval = Coerce.integer(envVars.dataspaceActivityLogsCleanupInterval);
+        coreConfig.types.dataspaceDataPlaneComponent ??= [];
+        coreConfig.types.dataspaceDataPlaneComponent.push({
+            type: DataspaceDataPlaneComponentType.Service,
+            options: {
+                config: {
+                    retainActivityLogsForMs: !Is.empty(retainActivityLogsFor)
+                        ? retainActivityLogsFor * 1000
+                        : undefined,
+                    activityLogsCleanUpIntervalMs: !Is.empty(activityLogsCleanUpInterval)
+                        ? activityLogsCleanUpInterval * 1000
+                        : undefined
                 }
             }
         });
@@ -1087,6 +1296,7 @@ async function configureDataSpaceConnector(coreConfig, envVars) {
  * Configures the DLT.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
+ * @returns A promise that resolves when the DLT configuration has been applied.
  */
 async function configureDlt(coreConfig, envVars) {
     // Create centralized DLT configuration for IOTA if essential IOTA variables are set
@@ -1108,7 +1318,7 @@ async function configureDlt(coreConfig, envVars) {
                         url: envVars.iotaNodeEndpoint ?? ""
                     },
                     network: envVars.iotaNetwork ?? "",
-                    coinType: Coerce.number(envVars.iotaCoinType),
+                    coinType: Coerce.integer(envVars.iotaCoinType),
                     gasStation: gasStationConfig
                 }
             }
@@ -1126,4 +1336,90 @@ function commaSeparatedListToArray(value) {
         .map(item => item.trim())
         .filter(item => item.length > 0);
 }
+/**
+ * Checks if the trust subsystem is required.
+ * Returns true when any component that depends on the trust subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if rights-management, or dataspace is enabled.
+ */
+export function isTrustRequired(envVars) {
+    return (isRightsManagementRequired(envVars) ||
+        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        isFederatedCatalogueRequired(envVars));
+}
+/**
+ * Checks if the background tasks subsystem is required.
+ * Returns true when any component that depends on the background tasks subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if dataspace or verifiable storage is enabled.
+ */
+export function isBackgroundTasksRequired(envVars) {
+    return (Coerce.boolean(envVars.dataspaceEnabled) ?? false) || isImmutableProofRequired(envVars);
+}
+/**
+ * Checks if the immutable proof subsystem is required.
+ * Returns true when any component that depends on the immutable proof subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if verifiable storage is enabled.
+ */
+export function isImmutableProofRequired(envVars) {
+    return ((Coerce.boolean(envVars.auditableItemGraphEnabled) ?? false) ||
+        (Coerce.boolean(envVars.auditableItemStreamEnabled) ?? false) ||
+        (Coerce.boolean(envVars.documentManagementEnabled) ?? false));
+}
+/**
+ * Checks if the federated catalogue subsystem is required.
+ * Returns true when the catalogue is explicitly enabled, a remote endpoint is configured, filters are set, or dataspace is enabled.
+ * @param envVars The environment variables.
+ * @returns True if the federated catalogue is required.
+ */
+export function isFederatedCatalogueRequired(envVars) {
+    return ((Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) ||
+        Is.stringValue(envVars.federatedCatalogueRemoteEndpoint) ||
+        Is.stringValue(envVars.federatedCatalogueFilters) ||
+        (Coerce.boolean(envVars.dataspaceEnabled) ?? false));
+}
+/**
+ * Checks if the rights management subsystem is required.
+ * Returns true when any component that depends on the rights management subsystem is enabled.
+ * Note: rights management has no standalone enable flag - it is gated entirely on
+ * `dataspaceEnabled`. Setting `TWIN_RIGHTS_MANAGEMENT_*` env var in isolation does not
+ * enable the subsystem; `TWIN_DATASPACE_ENABLED` must also be true.
+ * @param envVars The environment variables.
+ * @returns True if rights management is enabled.
+ */
+export function isRightsManagementRequired(envVars) {
+    return Coerce.boolean(envVars.dataspaceEnabled) ?? false;
+}
+/**
+ * Checks if the task scheduler subsystem is required.
+ * Returns true when any component that depends on the task scheduler subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if task scheduler is enabled.
+ */
+export function isTaskSchedulerRequired(envVars) {
+    return ((Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) ||
+        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        isRightsManagementRequired(envVars) ||
+        isAuthEntityStorageRequired(envVars));
+}
+/**
+ * Checks if the automation subsystem is required.
+ * Returns true when any component that depends on the automation subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if automation is enabled.
+ */
+export function isAutomationRequired(envVars) {
+    return isRightsManagementRequired(envVars);
+}
+/**
+ * Checks if the telemetry subsystem is required.
+ * Returns true when any component that depends on the telemetry subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if telemetry is enabled.
+ */
+export function isTelemetryRequired(envVars) {
+    return (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage ||
+        envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry);
+}
 //# sourceMappingURL=engineEnvBuilder.js.map