@twin.org/node-core 0.9.2-next.6 → 0.9.2-next.7

package/dist/es/builders/engineEnvBuilder.js

@@ -1,13 +1,14 @@
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 import path from "node:path";
-import { Coerce, Is, Mutex } from "@twin.org/core";
+import { 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, SchemaVersionMigrationComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TracingComponentType, TracingConnectorType, TrustComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
 import { OpenTelemetryExporterTypes } from "@twin.org/logging-connector-opentelemetry";
 import { OpenTelemetryReaderTypes } from "@twin.org/telemetry-connector-opentelemetry";
 import { OpenTelemetryProcessorTypes } from "@twin.org/tracing-connector-opentelemetry";
 import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT } from "../defaults.js";
 import { isAuthEntityStorageRequired } from "./engineServerEnvBuilder.js";
+import { commaSeparatedListToArray, envBoolean, envCount, envDateTime, envInteger, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
 /**
  * Build the engine core configuration from environment variables.
  * @param envVars The environment variables.
@@ -20,12 +21,12 @@ export async function buildEngineConfiguration(envVars) {
         envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
     }
     const coreConfig = {
-        debug: Coerce.boolean(envVars.debug) ?? false,
-        silent: Coerce.boolean(envVars.silent) ?? false,
+        debug: envBoolean(envVars, "debug", false),
+        silent: envBoolean(envVars, "silent", false),
         silentLoggers: commaSeparatedListToArray(envVars.loggingSilentComponents),
         types: {}
     };
-    const mutexTimeoutMs = Coerce.integer(envVars.mutexTimeoutMsDefault);
+    const mutexTimeoutMs = envMs(envVars, "mutexTimeoutMsDefault");
     if (!Is.empty(mutexTimeoutMs)) {
         Mutex.setDefaultTimeoutMs(mutexTimeoutMs);
     }
@@ -81,7 +82,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             type: EntityStorageConnectorType.Memory,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.entityStorageMemoryMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 }
             }
         });
@@ -92,7 +93,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     directory: envVars.storageFileRoot ?? "",
-                    mutexTimeoutMs: Coerce.integer(envVars.entityStorageFileMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 },
                 folderPrefix: envVars.entityStorageTablePrefix
             }
@@ -108,7 +109,7 @@ async function configureEntityStorage(coreConfig, envVars) {
                     accessKeyId: envVars.awsDynamodbAccessKeyId,
                     secretAccessKey: envVars.awsDynamodbSecretAccessKey,
                     endpoint: envVars.awsDynamodbEndpoint,
-                    connectionTimeoutMs: Coerce.integer(envVars.awsDynamodbConnectionTimeout)
+                    connectionTimeoutMs: envMs(envVars, "awsDynamodbConnectionTimeout")
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -151,7 +152,7 @@ async function configureEntityStorage(coreConfig, envVars) {
                     hosts: commaSeparatedListToArray(envVars.scylladbHosts),
                     localDataCenter: envVars.scylladbLocalDataCenter ?? "",
                     keyspace: envVars.scylladbKeyspace ?? "",
-                    port: Coerce.integer(envVars.scylladbPort)
+                    port: envInteger(envVars, "scylladbPort")
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -163,7 +164,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     host: envVars.mySqlHost ?? "",
-                    port: Coerce.integer(envVars.mySqlPort),
+                    port: envInteger(envVars, "mySqlPort"),
                     user: envVars.mySqlUser ?? "",
                     password: envVars.mySqlPassword ?? "",
                     database: envVars.mySqlDatabase ?? ""
@@ -178,7 +179,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     host: envVars.mongoDbHost ?? "",
-                    port: Coerce.integer(envVars.mongoDbPort),
+                    port: envInteger(envVars, "mongoDbPort"),
                     user: envVars.mongoDbUser ?? "",
                     password: envVars.mongoDbPassword ?? "",
                     database: envVars.mongoDbDatabase ?? ""
@@ -193,7 +194,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     host: envVars.postgreSqlHost ?? "",
-                    port: Coerce.integer(envVars.postgreSqlPort),
+                    port: envInteger(envVars, "postgreSqlPort"),
                     user: envVars.postgreSqlUser ?? "",
                     password: envVars.postgreSqlPassword ?? "",
                     database: envVars.postgreSqlDatabase ?? ""
@@ -344,13 +345,13 @@ async function configureLogging(coreConfig, envVars) {
                 type: LoggingConnectorType.EntityStorage,
                 options: {
                     config: {
-                        batchSize: Coerce.integer(envVars.loggingBatchSize),
-                        batchIntervalMs: (Coerce.integer(envVars.loggingBatchFlushInterval) ?? 5) * 1000,
-                        retainForMs: (Coerce.integer(envVars.loggingRetainFor) ?? 2880) * 60_000,
-                        maxEntries: Coerce.integer(envVars.loggingMaxEntries),
-                        retentionIntervalMs: (Coerce.integer(envVars.loggingRetentionInterval) ?? 5) * 60_000,
-                        retentionBatchSize: Coerce.integer(envVars.loggingRetentionBatchSize),
-                        mutexTimeoutMs: Coerce.integer(envVars.loggingMutexTimeout)
+                        batchSize: envCount(envVars, "loggingBatchSize"),
+                        batchIntervalMs: envSecToMs(envVars, "loggingBatchFlushInterval"),
+                        retainForMs: envMinToMs(envVars, "loggingRetainFor"),
+                        maxEntries: envCount(envVars, "loggingMaxEntries"),
+                        retentionIntervalMs: envMinToMs(envVars, "loggingRetentionInterval"),
+                        retentionBatchSize: envCount(envVars, "loggingRetentionBatchSize"),
+                        mutexTimeoutMs: envMs(envVars, "loggingMutexTimeout")
                     }
                 }
             });
@@ -386,9 +387,9 @@ async function configureLogging(coreConfig, envVars) {
                     config: {
                         directory: envVars.loggingFileDirectory ?? envVars.storageFileRoot ?? "",
                         filename: envVars.loggingFileFilename,
-                        maxFileSizeBytes: Coerce.integer(envVars.loggingFileMaxFileSizeBytes),
-                        maxRetainedFiles: Coerce.integer(envVars.loggingFileMaxRetainedFiles),
-                        mutexTimeoutMs: Coerce.integer(envVars.loggingMutexTimeout)
+                        maxFileSizeBytes: envCount(envVars, "loggingFileMaxFileSizeBytes"),
+                        maxRetainedFiles: envCount(envVars, "loggingFileMaxRetainedFiles"),
+                        mutexTimeoutMs: envMs(envVars, "loggingMutexTimeout")
                     }
                 }
             });
@@ -494,7 +495,7 @@ async function configureTelemetry(coreConfig, envVars) {
             type: TelemetryConnectorType.EntityStorage,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.telemetryMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout")
                 }
             }
         });
@@ -505,7 +506,7 @@ async function configureTelemetry(coreConfig, envVars) {
             readers = {
                 prometheus: {
                     type: OpenTelemetryReaderTypes.Prometheus,
-                    port: Coerce.integer(envVars.openTelemetryPrometheusPort)
+                    port: envCount(envVars, "openTelemetryPrometheusPort")
                 }
             };
         }
@@ -513,7 +514,7 @@ async function configureTelemetry(coreConfig, envVars) {
             type: TelemetryConnectorType.OpenTelemetry,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.telemetryMutexTimeout),
+                    mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout"),
                     meterName: envVars.openTelemetryMeterName,
                     meterVersion: envVars.openTelemetryMeterVersion,
                     readers
@@ -534,21 +535,23 @@ async function configureTelemetry(coreConfig, envVars) {
  */
 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 } },
+            options: {
+                config: {
+                    intervalMs: envSecToMs(envVars, "telemetryMetricsCollectorInterval")
+                }
+            },
             isCloneable: false
         });
-        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 },
+                options: { maxHistory: envCount(envVars, "telemetryMetricsProducerMaxHistory") },
                 isCloneable: false
             });
         }
@@ -567,7 +570,7 @@ async function configureTracing(coreConfig, envVars) {
             type: TracingConnectorType.EntityStorage,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.tracingMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "tracingMutexTimeout")
                 }
             }
         });
@@ -630,14 +633,14 @@ async function configureAutomation(coreConfig, envVars) {
  */
 async function configureHealth(coreConfig, envVars) {
     coreConfig.types.healthComponent ??= [];
-    if (Coerce.boolean(envVars.healthEnabled) ?? false) {
+    if (envBoolean(envVars, "healthEnabled", false)) {
         coreConfig.types.healthComponent.push({
             type: HealthComponentType.Service,
             options: {
                 config: {
-                    healthCheckInterval: (Coerce.integer(envVars.healthInterval) ?? 60) * 1000,
-                    healthCheckApplicationInterval: (Coerce.integer(envVars.healthApplicationInterval) ?? 300) * 1000,
-                    initialInterval: (Coerce.integer(envVars.healthStartupInterval) ?? 2) * 1000
+                    healthCheckInterval: envSecToMs(envVars, "healthInterval"),
+                    healthCheckApplicationInterval: envSecToMs(envVars, "healthApplicationInterval"),
+                    initialInterval: envSecToMs(envVars, "healthStartupInterval")
                 }
             },
             isCloneable: false
@@ -651,7 +654,7 @@ async function configureHealth(coreConfig, envVars) {
  * @returns A promise that resolves when the schema migration configuration has been applied.
  */
 async function configureSchemaMigration(coreConfig, envVars) {
-    const isSchemaMigrationEnabled = Coerce.boolean(envVars.schemaMigrationEnabled) ?? true;
+    const isSchemaMigrationEnabled = envBoolean(envVars, "schemaMigrationEnabled", true);
     if (isSchemaMigrationEnabled) {
         coreConfig.types.schemaVersionMigrationComponent ??= [];
         coreConfig.types.schemaVersionMigrationComponent.push({
@@ -667,7 +670,7 @@ async function configureSchemaMigration(coreConfig, envVars) {
  * @returns A promise that resolves when the platform configuration has been applied.
  */
 async function configurePlatform(coreConfig, envVars) {
-    const isTenantEnabled = Coerce.boolean(envVars.tenantEnabled) ?? false;
+    const isTenantEnabled = envBoolean(envVars, "tenantEnabled", false);
     coreConfig.types.platformComponent ??= [];
     coreConfig.types.platformComponent.push({
         type: PlatformComponentType.Service,
@@ -685,7 +688,7 @@ async function configurePlatform(coreConfig, envVars) {
  * @returns A promise that resolves when the tenant configuration has been applied.
  */
 async function configureTenant(coreConfig, envVars) {
-    const isTenantEnabled = Coerce.boolean(envVars.tenantEnabled) ?? false;
+    const isTenantEnabled = envBoolean(envVars, "tenantEnabled", false);
     if (isTenantEnabled) {
         coreConfig.types.tenantAdminComponent ??= [];
         coreConfig.types.tenantAdminComponent.push({
@@ -705,7 +708,7 @@ async function configureContextIdHandlers(coreConfig, envVars) {
         type: ContextIdHandlerComponentType.Did,
         features: [CONTEXT_ID_HANDLER_FEATURE_DID]
     });
-    if (Coerce.boolean(envVars.tenantEnabled) ?? false) {
+    if (envBoolean(envVars, "tenantEnabled", false)) {
         coreConfig.types.contextIdHandlerComponent.push({
             type: ContextIdHandlerComponentType.Tenant,
             features: [CONTEXT_ID_HANDLER_FEATURE_TENANT]
@@ -719,7 +722,7 @@ async function configureContextIdHandlers(coreConfig, envVars) {
  * @returns A promise that resolves when the messaging configuration has been applied.
  */
 async function configureMessaging(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.messagingEnabled) ?? false) {
+    if (envBoolean(envVars, "messagingEnabled", false)) {
         coreConfig.types.messagingEmailConnector ??= [];
         coreConfig.types.messagingSmsConnector ??= [];
         coreConfig.types.messagingPushNotificationConnector ??= [];
@@ -923,9 +926,15 @@ async function configureImmutableProof(coreConfig, envVars) {
             options: {
                 config: {
                     verificationMethodId: envVars.immutableProofVerificationMethodId,
-                    taskRetryCount: Coerce.integer(envVars.immutableProofTaskRetryCount),
-                    taskRetryInterval: (Coerce.integer(envVars.immutableProofTaskRetryInterval) ?? 5) * 1000,
-                    taskFailureRetainFor: (Coerce.integer(envVars.immutableProofTaskFailureRetainFor) ?? 10080) * 60_000
+                    taskRetryCount: envCount(envVars, "immutableProofTaskRetryCount"),
+                    taskRetryInterval: envSecToMs(envVars, "immutableProofTaskRetryInterval"),
+                    taskFailureRetainFor: envMinToMs(envVars, "immutableProofTaskFailureRetainFor"),
+                    sweepIntervalMinutes: envMinutes(envVars, "immutableProofSweepInterval"),
+                    sweepStaleThresholdMs: envMinToMs(envVars, "immutableProofSweepStaleThreshold"),
+                    sweepMaxAttempts: envCount(envVars, "immutableProofSweepMaxAttempts"),
+                    sweepBatchLimit: envCount(envVars, "immutableProofSweepBatchLimit"),
+                    sweepBackoffMs: envMinToMs(envVars, "immutableProofSweepBackoff"),
+                    sweepAssumeRetryableBefore: envDateTime(envVars, "immutableProofSweepAssumeRetryableBefore")
                 }
             }
         });
@@ -954,8 +963,8 @@ async function configureIdentity(coreConfig, envVars) {
                     identityPkgId: Is.stringValue(envVars.iotaIdentityPackageId)
                         ? envVars.iotaIdentityPackageId
                         : undefined,
-                    walletAddressIndex: Coerce.integer(envVars.identityWalletAddressIndex) ?? 0,
-                    didResolutionCacheTtlMs: Coerce.integer(envVars.identityDidResolutionCacheTtlMs)
+                    walletAddressIndex: envCount(envVars, "identityWalletAddressIndex") ?? 0,
+                    didResolutionCacheTtlMs: envMs(envVars, "identityDidResolutionCacheTtlMs")
                 }
             }
         });
@@ -1059,13 +1068,13 @@ async function configureAttestation(coreConfig, envVars) {
  * @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) {
+    if (envBoolean(envVars, "auditableItemGraphEnabled", false)) {
         coreConfig.types.auditableItemGraphComponent ??= [];
         coreConfig.types.auditableItemGraphComponent.push({
             type: AuditableItemGraphComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.auditableItemGraphMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "auditableItemGraphMutexTimeout")
                 }
             }
         });
@@ -1078,13 +1087,13 @@ async function configureAuditableItemGraph(coreConfig, envVars) {
  * @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) {
+    if (envBoolean(envVars, "auditableItemStreamEnabled", false)) {
         coreConfig.types.auditableItemStreamComponent ??= [];
         coreConfig.types.auditableItemStreamComponent.push({
             type: AuditableItemStreamComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.auditableItemStreamMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "auditableItemStreamMutexTimeout")
                 }
             }
         });
@@ -1097,7 +1106,7 @@ async function configureAuditableItemStream(coreConfig, envVars) {
  * @returns A promise that resolves when the data processing configuration has been applied.
  */
 async function configureDataProcessing(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.dataProcessingEnabled) ?? false) {
+    if (envBoolean(envVars, "dataProcessingEnabled", false)) {
         coreConfig.types.dataProcessingComponent ??= [];
         coreConfig.types.dataProcessingComponent.push({ type: DataProcessingComponentType.Service });
         coreConfig.types.dataConverterConnector ??= [];
@@ -1123,13 +1132,13 @@ async function configureDataProcessing(coreConfig, envVars) {
  * @returns A promise that resolves when the document management configuration has been applied.
  */
 async function configureDocumentManagement(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.documentManagementEnabled) ?? false) {
+    if (envBoolean(envVars, "documentManagementEnabled", false)) {
         coreConfig.types.documentManagementComponent ??= [];
         coreConfig.types.documentManagementComponent.push({
             type: DocumentManagementComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.documentManagementMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "documentManagementMutexTimeout")
                 }
             }
         });
@@ -1155,7 +1164,7 @@ async function configureTrust(coreConfig, envVars) {
                 options: {
                     config: {
                         verificationMethodId: envVars.trustVerificationMethodId ?? "",
-                        tokenTtlInSeconds: Coerce.integer(envVars.trustJwtTtl)
+                        tokenTtlInSeconds: envCount(envVars, "trustJwtTtl")
                     }
                 }
             });
@@ -1240,7 +1249,7 @@ async function configureRightsManagement(coreConfig, envVars) {
                 config: {
                     callbackPath: rightsManagementPath,
                     includeErrorDetails: coreConfig.debug ?? false,
-                    mutexTimeoutMs: Coerce.integer(envVars.rightsManagementMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "rightsManagementMutexTimeout")
                 }
             },
             isDefault: true
@@ -1250,7 +1259,7 @@ async function configureRightsManagement(coreConfig, envVars) {
             type: RightsManagementPnapComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.rightsManagementMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "rightsManagementMutexTimeout")
                 }
             }
         });
@@ -1342,7 +1351,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
                 type: FederatedCatalogueComponentType.Service,
                 options: {
                     config: {
-                        mutexTimeoutMs: Coerce.integer(envVars.federatedCatalogueMutexTimeout)
+                        mutexTimeoutMs: envMs(envVars, "federatedCatalogueMutexTimeout")
                     }
                 }
             });
@@ -1364,7 +1373,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
  * @returns A promise that resolves when the dataspace configuration has been applied.
  */
 async function configureDataspace(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.dataspaceEnabled) ?? false) {
+    if (envBoolean(envVars, "dataspaceEnabled", false)) {
         coreConfig.types.dataspaceControlPlaneComponent ??= [];
         // We add a multi instance REST client for remote/consumer-initiated transfers.
         coreConfig.types.dataspaceControlPlaneComponent.push({
@@ -1375,8 +1384,6 @@ async function configureDataspace(coreConfig, envVars) {
             isMultiInstance: true,
             features: ["remote"]
         });
-        const stalledNegotiationTimeout = Coerce.integer(envVars.dataspaceStalledNegotiationTimeout);
-        const stalledTransferTimeout = Coerce.integer(envVars.dataspaceStalledTransferTimeout);
         coreConfig.types.dataspaceControlPlaneComponent.push({
             type: DataspaceControlPlaneComponentType.Service,
             options: {
@@ -1387,30 +1394,22 @@ async function configureDataspace(coreConfig, envVars) {
                     // Base mount path of the data plane only; the transfer handlers append the
                     // sub-paths themselves (`/entities` for PULL, `/inbox` for PUSH).
                     dataPlanePath: envVars.dataspaceDataPlanePath,
-                    autoStartTransfers: Coerce.boolean(envVars.dataspaceAutoStartTransfers),
-                    stalledNegotiationTimeoutMs: !Is.empty(stalledNegotiationTimeout)
-                        ? stalledNegotiationTimeout * 1000
-                        : undefined,
-                    stalledTransferTimeoutMs: !Is.empty(stalledTransferTimeout)
-                        ? stalledTransferTimeout * 1000
-                        : undefined
+                    autoStartTransfers: envBoolean(envVars, "dataspaceAutoStartTransfers", false),
+                    stalledNegotiationTimeoutMs: envSecToMs(envVars, "dataspaceStalledNegotiationTimeout"),
+                    stalledTransferTimeoutMs: envSecToMs(envVars, "dataspaceStalledTransferTimeout"),
+                    providerTransferIdleTimeoutMs: envSecToMs(envVars, "dataspaceProviderTransferIdleTimeout"),
+                    providerTransferPolicySweepIntervalMs: envSecToMs(envVars, "dataspaceProviderTransferPolicySweepInterval")
                 }
             },
             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
+                    retainActivityLogsForMs: envSecToMs(envVars, "dataspaceRetainActivityLogsFor"),
+                    activityLogsCleanUpIntervalMs: envSecToMs(envVars, "dataspaceActivityLogsCleanupInterval")
                 }
             }
         });
@@ -1442,26 +1441,15 @@ async function configureDlt(coreConfig, envVars) {
                         url: envVars.iotaNodeEndpoint ?? ""
                     },
                     network: envVars.iotaNetwork ?? "",
-                    coinType: Coerce.integer(envVars.iotaCoinType),
+                    coinType: envCount(envVars, "iotaCoinType"),
                     gasStation: gasStationConfig,
-                    gasBudget: Coerce.integer(envVars.iotaGasBudget),
-                    gasReservationDuration: Coerce.integer(envVars.iotaGasReservationDuration)
+                    gasBudget: envCount(envVars, "iotaGasBudget"),
+                    gasReservationDuration: envSeconds(envVars, "iotaGasReservationDuration")
                 }
             }
         });
     }
 }
-/**
- * Converts a comma separated list to an array.
- * @param value The comma separated list.
- * @returns The array.
- */
-function commaSeparatedListToArray(value) {
-    return (value ?? "")
-        .split(",")
-        .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.
@@ -1470,7 +1458,7 @@ function commaSeparatedListToArray(value) {
  */
 export function isTrustRequired(envVars) {
     return (isRightsManagementRequired(envVars) ||
-        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        envBoolean(envVars, "dataspaceEnabled", false) ||
         isFederatedCatalogueRequired(envVars));
 }
 /**
@@ -1480,7 +1468,7 @@ export function isTrustRequired(envVars) {
  * @returns True if dataspace or verifiable storage is enabled.
  */
 export function isBackgroundTasksRequired(envVars) {
-    return (Coerce.boolean(envVars.dataspaceEnabled) ?? false) || isImmutableProofRequired(envVars);
+    return envBoolean(envVars, "dataspaceEnabled", false) || isImmutableProofRequired(envVars);
 }
 /**
  * Checks if the immutable proof subsystem is required.
@@ -1489,9 +1477,9 @@ export function isBackgroundTasksRequired(envVars) {
  * @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));
+    return (envBoolean(envVars, "auditableItemGraphEnabled", false) ||
+        envBoolean(envVars, "auditableItemStreamEnabled", false) ||
+        envBoolean(envVars, "documentManagementEnabled", false));
 }
 /**
  * Checks if the federated catalogue subsystem is required.
@@ -1500,10 +1488,10 @@ export function isImmutableProofRequired(envVars) {
  * @returns True if the federated catalogue is required.
  */
 export function isFederatedCatalogueRequired(envVars) {
-    return ((Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) ||
+    return (envBoolean(envVars, "federatedCatalogueEnabled", false) ||
         Is.stringValue(envVars.federatedCatalogueRemoteEndpoint) ||
         Is.stringValue(envVars.federatedCatalogueFilters) ||
-        (Coerce.boolean(envVars.dataspaceEnabled) ?? false));
+        envBoolean(envVars, "dataspaceEnabled", false));
 }
 /**
  * Checks if the rights management subsystem is required.
@@ -1515,7 +1503,7 @@ export function isFederatedCatalogueRequired(envVars) {
  * @returns True if rights management is enabled.
  */
 export function isRightsManagementRequired(envVars) {
-    return Coerce.boolean(envVars.dataspaceEnabled) ?? false;
+    return envBoolean(envVars, "dataspaceEnabled", false);
 }
 /**
  * Checks if the task scheduler subsystem is required.
@@ -1524,8 +1512,8 @@ export function isRightsManagementRequired(envVars) {
  * @returns True if task scheduler is enabled.
  */
 export function isTaskSchedulerRequired(envVars) {
-    return ((Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) ||
-        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+    return (envBoolean(envVars, "taskSchedulerEnabled", false) ||
+        envBoolean(envVars, "dataspaceEnabled", false) ||
         isRightsManagementRequired(envVars) ||
         isAuthEntityStorageRequired(envVars) ||
         isImmutableProofRequired(envVars));