@twin.org/engine-core 0.0.1-next.9 → 0.0.1

package/dist/cjs/index.cjs

@@ -1,1185 +1,65 @@
 'use strict';
 
-var path = require('node:path');
 var core = require('@twin.org/core');
-var engineModels = require('@twin.org/engine-models');
-var entityStorageConnectorCosmosdb = require('@twin.org/entity-storage-connector-cosmosdb');
-var entityStorageConnectorDynamodb = require('@twin.org/entity-storage-connector-dynamodb');
-var entityStorageConnectorFile = require('@twin.org/entity-storage-connector-file');
-var entityStorageConnectorGcpFirestore = require('@twin.org/entity-storage-connector-gcp-firestore');
-var entityStorageConnectorMemory = require('@twin.org/entity-storage-connector-memory');
-var entityStorageConnectorScylladb = require('@twin.org/entity-storage-connector-scylladb');
-var entityStorageModels = require('@twin.org/entity-storage-models');
-var entityStorageService = require('@twin.org/entity-storage-service');
+var entity = require('@twin.org/entity');
 var loggingConnectorConsole = require('@twin.org/logging-connector-console');
 var loggingModels = require('@twin.org/logging-models');
-var attestationConnectorEntityStorage = require('@twin.org/attestation-connector-entity-storage');
-var attestationConnectorIota = require('@twin.org/attestation-connector-iota');
-var attestationModels = require('@twin.org/attestation-models');
-var attestationService = require('@twin.org/attestation-service');
-var auditableItemGraphService = require('@twin.org/auditable-item-graph-service');
-var auditableItemStreamService = require('@twin.org/auditable-item-stream-service');
-var backgroundTaskConnectorEntityStorage = require('@twin.org/background-task-connector-entity-storage');
-var backgroundTaskModels = require('@twin.org/background-task-models');
-var blobStorageConnectorAwsS3 = require('@twin.org/blob-storage-connector-aws-s3');
-var blobStorageConnectorAzure = require('@twin.org/blob-storage-connector-azure');
-var blobStorageConnectorFile = require('@twin.org/blob-storage-connector-file');
-var blobStorageConnectorGcp = require('@twin.org/blob-storage-connector-gcp');
-var blobStorageConnectorIpfs = require('@twin.org/blob-storage-connector-ipfs');
-var blobStorageConnectorMemory = require('@twin.org/blob-storage-connector-memory');
-var blobStorageModels = require('@twin.org/blob-storage-models');
-var blobStorageService = require('@twin.org/blob-storage-service');
-var walletConnectorEntityStorage = require('@twin.org/wallet-connector-entity-storage');
-var walletConnectorIota = require('@twin.org/wallet-connector-iota');
-var walletModels = require('@twin.org/wallet-models');
-var identityConnectorEntityStorage = require('@twin.org/identity-connector-entity-storage');
-var identityConnectorIota = require('@twin.org/identity-connector-iota');
-var identityModels = require('@twin.org/identity-models');
-var identityService = require('@twin.org/identity-service');
-var immutableProofService = require('@twin.org/immutable-proof-service');
-var immutableStorageConnectorEntityStorage = require('@twin.org/immutable-storage-connector-entity-storage');
-var immutableStorageConnectorIota = require('@twin.org/immutable-storage-connector-iota');
-var immutableStorageModels = require('@twin.org/immutable-storage-models');
-var loggingConnectorEntityStorage = require('@twin.org/logging-connector-entity-storage');
-var loggingService = require('@twin.org/logging-service');
-var nftConnectorEntityStorage = require('@twin.org/nft-connector-entity-storage');
-var nftConnectorIota = require('@twin.org/nft-connector-iota');
-var nftModels = require('@twin.org/nft-models');
-var nftService = require('@twin.org/nft-service');
-var telemetryConnectorEntityStorage = require('@twin.org/telemetry-connector-entity-storage');
-var telemetryModels = require('@twin.org/telemetry-models');
-var telemetryService = require('@twin.org/telemetry-service');
-var vaultConnectorEntityStorage = require('@twin.org/vault-connector-entity-storage');
-var vaultConnectorHashicorp = require('@twin.org/vault-connector-hashicorp');
-var vaultModels = require('@twin.org/vault-models');
+var modules = require('@twin.org/modules');
 var promises = require('node:fs/promises');
+var path = require('node:path');
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Initialise the entity storage connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param typeCustom Override the type of connector to use instead of default configuration.
- * @param schema The schema for the entity storage.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseEntityStorageConnector(engineCore, context, typeCustom, schema) {
-    const instanceName = core.StringHelper.kebabCase(schema);
-    let entityStorageConfig;
-    if (core.Is.stringValue(typeCustom)) {
-        // A custom type has been specified, so look it up
-        entityStorageConfig = context.config.entityStorageConnector?.find(c => c.type === typeCustom || c.overrideInstanceType === typeCustom);
-        if (core.Is.empty(entityStorageConfig)) {
-            throw new core.GeneralError("engineCore", "entityStorageCustomMissing", {
-                typeCustom,
-                storageName: instanceName
-            });
-        }
-    }
-    else {
-        // The default entity storage method is either the one with the isDefault flag set
-        // or pick the first one if no default is set.
-        entityStorageConfig =
-            context.config.entityStorageConnector?.find(c => c.isDefault ?? false) ??
-                context.config.entityStorageConnector?.[0];
-        if (core.Is.empty(entityStorageConfig)) {
-            throw new core.GeneralError("engineCore", "entityStorageMissing", {
-                storageName: instanceName
-            });
-        }
-    }
-    const type = entityStorageConfig.type;
-    let entityStorageConnector;
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuringEntityStorage", {
-        element: "Entity Storage",
-        storageName: instanceName,
-        storageType: type
-    }));
-    if (type === engineModels.EntityStorageConnectorType.Memory) {
-        entityStorageConnector = new entityStorageConnectorMemory.MemoryEntityStorageConnector({
-            entitySchema: schema
-        });
-    }
-    else if (type === engineModels.EntityStorageConnectorType.File) {
-        entityStorageConnector = new entityStorageConnectorFile.FileEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                directory: path.join(entityStorageConfig.options.config.directory, instanceName)
-            }
-        });
-    }
-    else if (type === engineModels.EntityStorageConnectorType.AwsDynamoDb) {
-        entityStorageConnector = new entityStorageConnectorDynamodb.DynamoDbEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else if (type === engineModels.EntityStorageConnectorType.AzureCosmosDb) {
-        entityStorageConnector = new entityStorageConnectorCosmosdb.CosmosDbEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                containerId: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else if (type === engineModels.EntityStorageConnectorType.GcpFirestoreDb) {
-        entityStorageConnector = new entityStorageConnectorGcpFirestore.FirestoreEntityStorageConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                collectionName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else if (type === engineModels.EntityStorageConnectorType.ScyllaDb) {
-        entityStorageConnector = new entityStorageConnectorScylladb.ScyllaDBTableConnector({
-            entitySchema: schema,
-            ...entityStorageConfig.options,
-            config: {
-                ...entityStorageConfig.options.config,
-                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
-            }
-        });
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "entityStorageConnector"
-        });
-    }
-    context.componentInstances.push({
-        instanceType: instanceName,
-        component: entityStorageConnector
-    });
-    entityStorageModels.EntityStorageConnectorFactory.register(instanceName, () => entityStorageConnector);
-}
-/**
- * Initialise the entity storage connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseEntityStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Entity Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.EntityStorageComponentType.Service) {
-        const kebabName = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
-        // See if there is a custom entity storage for this type, otherwise just use the default one.
-        const hasCustom = context.config.entityStorageConnector?.some(c => c.type === kebabName || c.overrideInstanceType === kebabName);
-        initialiseEntityStorageConnector(engineCore, context, hasCustom ? kebabName : undefined, instanceConfig.options.entityStorageType);
-        connector = new entityStorageService.EntityStorageService({
-            entityStorageType: kebabName,
-            config: {
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = core.StringHelper.kebabCase(instanceConfig.options.entityStorageType);
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            serviceType: "entityStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    core.ComponentFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the attestation connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseAttestationConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.AttestationConnectorType.Iota) {
-        connector = new attestationConnectorIota.IotaAttestationConnector({
-            identityConnectorType: context.defaultTypes.identityConnector,
-            nftConnectorType: context.defaultTypes.nftConnector,
-            ...instanceConfig.options
-        });
-        instanceType = attestationConnectorIota.IotaAttestationConnector.NAMESPACE;
-    }
-    else if (type === engineModels.AttestationConnectorType.EntityStorage) {
-        connector = new attestationConnectorEntityStorage.EntityStorageAttestationConnector({
-            identityConnectorType: context.defaultTypes.identityConnector,
-            nftConnectorType: context.defaultTypes.nftConnector,
-            ...instanceConfig.options
-        });
-        instanceType = attestationConnectorEntityStorage.EntityStorageAttestationConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "attestationConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    attestationModels.AttestationConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the attestation component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseAttestationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Attestation Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.AttestationComponentType.Service) {
-        component = new attestationService.AttestationService({
-            walletConnectorType: context.defaultTypes.walletConnector,
-            ...instanceConfig.options
-        });
-        instanceType = attestationService.AttestationService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "attestationComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-/**
- * Initialise the auditable item graph component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseAuditableItemGraphComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Graph Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.AuditableItemGraphComponentType.Service) {
-        auditableItemGraphService.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
-        component = new auditableItemGraphService.AuditableItemGraphService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            ...instanceConfig.options
-        });
-        instanceType = auditableItemGraphService.AuditableItemGraphService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemGraphComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-/**
- * Initialise the auditable item stream component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseAuditableItemStreamComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Auditable Item Stream Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.AuditableItemStreamComponentType.Service) {
-        auditableItemStreamService.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
-        component = new auditableItemStreamService.AuditableItemStreamService({
-            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
-            ...instanceConfig.options
-        });
-        instanceType = auditableItemStreamService.AuditableItemStreamService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "auditableItemStreamComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise a background task connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseBackgroundTaskConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Background Task Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.BackgroundTaskConnectorType.EntityStorage) {
-        backgroundTaskConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
-        connector = new backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            ...instanceConfig.options
-        });
-        instanceType = backgroundTaskConnectorEntityStorage.EntityStorageBackgroundTaskConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "backgroundTaskConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    backgroundTaskModels.BackgroundTaskConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the blob storage connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseBlobStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.BlobStorageConnectorType.Ipfs) {
-        connector = new blobStorageConnectorIpfs.IpfsBlobStorageConnector(instanceConfig.options);
-        instanceType = blobStorageConnectorIpfs.IpfsBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === engineModels.BlobStorageConnectorType.File) {
-        connector = new blobStorageConnectorFile.FileBlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                directory: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.directory}`
-            }
-        });
-        instanceType = blobStorageConnectorFile.FileBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === engineModels.BlobStorageConnectorType.Memory) {
-        connector = new blobStorageConnectorMemory.MemoryBlobStorageConnector();
-        instanceType = blobStorageConnectorMemory.MemoryBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === engineModels.BlobStorageConnectorType.AwsS3) {
-        connector = new blobStorageConnectorAwsS3.S3BlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
-            }
-        });
-        instanceType = blobStorageConnectorAwsS3.S3BlobStorageConnector.NAMESPACE;
-    }
-    else if (type === engineModels.BlobStorageConnectorType.GcpStorage) {
-        connector = new blobStorageConnectorGcp.GcpBlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
-            }
-        });
-        instanceType = blobStorageConnectorGcp.GcpBlobStorageConnector.NAMESPACE;
-    }
-    else if (type === engineModels.BlobStorageConnectorType.AzureStorage) {
-        connector = new blobStorageConnectorAzure.AzureBlobStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...instanceConfig.options.config,
-                containerName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.containerName}`
-            }
-        });
-        instanceType = blobStorageConnectorAzure.AzureBlobStorageConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "blobStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    blobStorageModels.BlobStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the blob storage component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseBlobStorageComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Blob Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.BlobStorageComponentType.Service) {
-        blobStorageService.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
-        component = new blobStorageService.BlobStorageService({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            ...instanceConfig.options
-        });
-        instanceType = blobStorageService.BlobStorageService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "blobStorageComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise a faucet connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseFaucetConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Faucet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.FaucetConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new walletConnectorIota.IotaFaucetConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = walletConnectorIota.IotaFaucetConnector.NAMESPACE;
-    }
-    else if (type === engineModels.FaucetConnectorType.EntityStorage) {
-        connector = new walletConnectorEntityStorage.EntityStorageFaucetConnector(instanceConfig.options);
-        instanceType = walletConnectorEntityStorage.EntityStorageFaucetConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "faucetConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    walletModels.FaucetConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the identity connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseIdentityConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.IdentityConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new identityConnectorIota.IotaIdentityConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = identityConnectorIota.IotaIdentityConnector.NAMESPACE;
-    }
-    else if (type === engineModels.IdentityConnectorType.EntityStorage) {
-        identityConnectorEntityStorage.initSchema({ includeProfile: false });
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
-        connector = new identityConnectorEntityStorage.EntityStorageIdentityConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            ...instanceConfig.options
-        });
-        instanceType = identityConnectorEntityStorage.EntityStorageIdentityConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "identityConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    identityModels.IdentityConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the identity component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseIdentityComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.IdentityComponentType.Service) {
-        component = new identityService.IdentityService(instanceConfig.options);
-        instanceType = identityService.IdentityService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the identity profile connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseIdentityProfileConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.IdentityProfileConnectorType.EntityStorage) {
-        identityConnectorEntityStorage.initSchema({ includeDocument: false });
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.profileEntityStorageType, "IdentityProfile");
-        connector = new identityConnectorEntityStorage.EntityStorageIdentityProfileConnector(instanceConfig.options);
-        instanceType = identityConnectorEntityStorage.EntityStorageIdentityProfileConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            serviceType: "identityProfile"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    identityModels.IdentityProfileConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the identity profile component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseIdentityProfileComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Identity Profile Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.IdentityProfileComponentType.Service) {
-        component = new identityService.IdentityProfileService({
-            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
-            ...instanceConfig.options
-        });
-        instanceType = identityService.IdentityProfileService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "identityProfileComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the immutable proof component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseImmutableProofComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Immutable Proof Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.ImmutableProofComponentType.Service) {
-        immutableProofService.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
-        component = new immutableProofService.ImmutableProofService({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            immutableStorageType: context.defaultTypes.immutableStorageConnector,
-            identityConnectorType: context.defaultTypes.identityConnector,
-            backgroundTaskConnectorType: context.defaultTypes.backgroundTaskConnector,
-            ...instanceConfig.options
-        });
-        instanceType = immutableProofService.ImmutableProofService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "immutableProofComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the immutable storage connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseImmutableStorageConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Immutable Storage Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.ImmutableStorageConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new immutableStorageConnectorIota.IotaImmutableStorageConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = immutableStorageConnectorIota.IotaImmutableStorageConnector.NAMESPACE;
-    }
-    else if (type === engineModels.ImmutableStorageConnectorType.EntityStorage) {
-        immutableStorageConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableStorageEntityStorageType, "ImmutableItem");
-        connector = new immutableStorageConnectorEntityStorage.EntityStorageImmutableStorageConnector(instanceConfig.options);
-        instanceType = immutableStorageConnectorEntityStorage.EntityStorageImmutableStorageConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "immutableStorageConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    immutableStorageModels.ImmutableStorageConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the logging connector.
- * @param engineCore The engine core.
- * @param context The engine core context.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseLoggingConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.LoggingConnectorType.Console) {
-        connector = new loggingConnectorConsole.ConsoleLoggingConnector(instanceConfig.options);
-        instanceType = loggingConnectorConsole.ConsoleLoggingConnector.NAMESPACE;
-    }
-    else if (type === engineModels.LoggingConnectorType.EntityStorage) {
-        loggingConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
-        connector = new loggingConnectorEntityStorage.EntityStorageLoggingConnector(instanceConfig.options);
-        instanceType = loggingConnectorEntityStorage.EntityStorageLoggingConnector.NAMESPACE;
-    }
-    else if (type === engineModels.LoggingConnectorType.Multi) {
-        connector = new loggingModels.MultiLoggingConnector(instanceConfig.options);
-        instanceType = loggingModels.MultiLoggingConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "loggingConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    loggingModels.LoggingConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the logging component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseLoggingComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Logging Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.LoggingComponentType.Service) {
-        component = new loggingService.LoggingService({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            ...instanceConfig.options
-        });
-        instanceType = loggingService.LoggingService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "loggingComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the NFT connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseNftConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `NFT Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.NftConnectorType.EntityStorage) {
-        nftConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
-        connector = new nftConnectorEntityStorage.EntityStorageNftConnector(instanceConfig.options);
-        instanceType = nftConnectorEntityStorage.EntityStorageNftConnector.NAMESPACE;
-    }
-    else if (type === engineModels.NftConnectorType.Iota) {
-        connector = new nftConnectorIota.IotaNftConnector({
-            ...instanceConfig.options
-        });
-        instanceType = nftConnectorIota.IotaNftConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "nftConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    nftModels.NftConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the NFT component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseNftComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Nft Storage Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.NftComponentType.Service) {
-        component = new nftService.NftService(instanceConfig.options);
-        instanceType = nftService.NftService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "nftComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component
-    });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise a telemetry connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseTelemetryConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.TelemetryConnectorType.EntityStorage) {
-        telemetryConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
-        connector = new telemetryConnectorEntityStorage.EntityStorageTelemetryConnector({
-            loggingConnectorType: context.defaultTypes.loggingConnector,
-            ...instanceConfig.options
-        });
-        instanceType = telemetryConnectorEntityStorage.EntityStorageTelemetryConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "telemetryConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    telemetryModels.TelemetryConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the telemetry component.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the component type is unknown.
- */
-function initialiseTelemetryComponent(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Telemetry Component: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let component;
-    let instanceType;
-    if (type === engineModels.TelemetryComponentType.Service) {
-        component = new telemetryService.TelemetryService({
-            telemetryConnectorType: context.defaultTypes.telemetryConnector,
-            ...instanceConfig.options
-        });
-        instanceType = telemetryService.TelemetryService.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "componentUnknownType", {
-            type,
-            componentType: "telemetryComponent"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component });
-    core.ComponentFactory.register(finalInstanceType, () => component);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise the vault connector.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseVaultConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Vault Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.VaultConnectorType.EntityStorage) {
-        vaultConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
-        connector = new vaultConnectorEntityStorage.EntityStorageVaultConnector(instanceConfig.options);
-        instanceType = vaultConnectorEntityStorage.EntityStorageVaultConnector.NAMESPACE;
-    }
-    else if (type === engineModels.VaultConnectorType.Hashicorp) {
-        connector = new vaultConnectorHashicorp.HashicorpVaultConnector(instanceConfig.options);
-        instanceType = vaultConnectorHashicorp.HashicorpVaultConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "vaultConnector"
-        });
-    }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
-    vaultModels.VaultConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialise a wallet connector.
- * @param engineCore The engine core.
- * @param context The context for the node.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns The name of the instance created.
- * @throws GeneralError if the connector type is unknown.
+ * Store state in memory.
  */
-function initialiseWalletConnector(engineCore, context, instanceConfig, overrideInstanceType) {
-    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
-        element: `Wallet Connector: ${instanceConfig.type}`
-    }));
-    const type = instanceConfig.type;
-    let connector;
-    let instanceType;
-    if (type === engineModels.WalletConnectorType.Iota) {
-        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
-        connector = new walletConnectorIota.IotaWalletConnector({
-            ...instanceConfig.options,
-            config: {
-                ...dltConfig?.options?.config,
-                ...instanceConfig.options.config
-            }
-        });
-        instanceType = walletConnectorIota.IotaWalletConnector.NAMESPACE;
-    }
-    else if (type === engineModels.WalletConnectorType.EntityStorage) {
-        connector = new walletConnectorEntityStorage.EntityStorageWalletConnector({
-            vaultConnectorType: context.defaultTypes.vaultConnector,
-            faucetConnectorType: context.defaultTypes.faucetConnector,
-            ...instanceConfig.options
-        });
-        instanceType = walletConnectorEntityStorage.EntityStorageWalletConnector.NAMESPACE;
-    }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
+class MemoryStateStorage {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "MemoryStateStorage";
+    /**
+     * Readonly mode state file is not updated.
+     * @internal
+     */
+    _readonlyMode;
+    /**
+     * The state object.
+     * @internal
+     */
+    _engineState;
+    /**
+     * Create a new instance of MemoryStateStorage.
+     * @param readonlyMode Whether the file is in read-only mode.
+     * @param state The initial state.
+     */
+    constructor(readonlyMode = false, state) {
+        this._readonlyMode = readonlyMode;
+        this._engineState = state;
     }
-    const finalInstanceType = overrideInstanceType ?? instanceType;
-    context.componentInstances.push({
-        instanceType: finalInstanceType,
-        component: connector
-    });
-    walletModels.WalletConnectorFactory.register(finalInstanceType, () => connector);
-    return finalInstanceType;
-}
-/**
- * Initialise the wallet storage.
- * @param engineCore The engine core.
- * @param context The context for the engine.
- * @param instanceConfig The instance config.
- * @param overrideInstanceType The instance type to override the default.
- * @returns Nothing.
- * @throws GeneralError if the connector type is unknown.
- */
-function initialiseWalletStorage(engineCore, context, instanceConfig, overrideInstanceType) {
-    const type = instanceConfig.type;
-    if (type === engineModels.WalletConnectorType.Iota) ;
-    else if (type === engineModels.WalletConnectorType.EntityStorage) {
-        walletConnectorEntityStorage.initSchema();
-        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+    /**
+     * Method for loading the state.
+     * @param engineCore The engine core to load the state for.
+     * @returns The state of the engine or undefined if it doesn't exist.
+     */
+    async load(engineCore) {
+        engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
+            filename: this._engineState
+        }));
+        return this._engineState;
     }
-    else {
-        throw new core.GeneralError("engineCore", "connectorUnknownType", {
-            type,
-            connectorType: "walletConnector"
-        });
+    /**
+     * Method for saving the state.
+     * @param engineCore The engine core to save the state for.
+     * @param state The state of the engine to save.
+     * @returns Nothing.
+     */
+    async save(engineCore, state) {
+        if (!this._readonlyMode) {
+            engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`));
+            this._engineState = state;
+        }
     }
-    return undefined;
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -1198,7 +78,6 @@ class EngineCore {
     CLASS_NAME = "EngineCore";
     /**
      * The core context.
-     * @internal
      */
     _context;
     /**
@@ -1216,11 +95,26 @@ class EngineCore {
      * @internal
      */
     _skipBootstrap;
+    /**
+     * The logger type name to use.
+     * @internal
+     */
+    _loggerTypeName;
     /**
      * The type initialisers.
      * @internal
      */
     _typeInitialisers;
+    /**
+     * Is the engine started.
+     * @internal
+     */
+    _isStarted;
+    /**
+     * Add type initialisers to the engine.
+     * @internal
+     */
+    _populateTypeInitialisers;
     /**
      * Method for bootstrapping any data for the engine.
      * @internal
@@ -1235,61 +129,94 @@ class EngineCore {
         options.config = options.config ?? {};
         options.config.debug = options.config.debug ?? false;
         options.config.silent = options.config.silent ?? false;
+        options.config.types ??= {};
         this._skipBootstrap = options.skipBootstrap ?? false;
+        this._populateTypeInitialisers = options.populateTypeInitialisers;
         this._customBootstrap = options.customBootstrap;
+        this._loggerTypeName = options.loggerTypeName ?? EngineCore.LOGGER_TYPE_NAME;
         this._typeInitialisers = [];
         this._context = {
             config: options.config,
             defaultTypes: {},
             componentInstances: [],
-            state: { bootstrappedComponents: [] },
+            state: { componentStates: {} },
             stateDirty: false
         };
         this._stateStorage = options.stateStorage;
-        this.addCoreTypeInitialisers();
+        this._isStarted = false;
+        if (core.Is.function(this._populateTypeInitialisers)) {
+            this._populateTypeInitialisers(this, this._context);
+        }
     }
     /**
      * Add a type initialiser.
      * @param type The type to add the initialiser for.
      * @param typeConfig The type config.
-     * @param initialiser The initialiser to add.
+     * @param module The name of the module which contains the initialiser method.
+     * @param method The name of the method to call.
      */
-    addTypeInitialiser(type, typeConfig, initialiser) {
+    addTypeInitialiser(type, typeConfig, module, method) {
         if (!core.Is.empty(typeConfig)) {
             this._typeInitialisers.push({
                 type,
                 typeConfig,
-                initialiser: initialiser
+                module,
+                method
             });
         }
     }
     /**
      * Start the engine core.
-     * @returns Nothing.
+     * @returns True if the start was successful.
      */
     async start() {
+        if (this._isStarted) {
+            return false;
+        }
         this.setupEngineLogger();
         this.logInfo(core.I18n.formatMessage("engineCore.starting"));
         if (this._context.config.debug) {
             this.logInfo(core.I18n.formatMessage("engineCore.debuggingEnabled"));
         }
-        if (await this.stateLoad()) {
-            for (const { type, typeConfig, initialiser } of this._typeInitialisers) {
-                this.initialiseTypeConfig(type, typeConfig, initialiser);
-            }
-            const canContinue = await this.bootstrap();
+        let canContinue;
+        try {
+            canContinue = await this.stateLoad();
             if (canContinue) {
+                for (const { type, typeConfig, module, method } of this._typeInitialisers) {
+                    await this.initialiseTypeConfig(type, typeConfig, module, method);
+                }
+                await this.bootstrap();
                 this.logInfo(core.I18n.formatMessage("engineCore.componentsStarting"));
                 for (const instance of this._context.componentInstances) {
                     if (core.Is.function(instance.component.start)) {
-                        this.logInfo(core.I18n.formatMessage("engineCore.componentStarting", { element: instance.instanceType }));
-                        await instance.component.start(this._context.state.nodeIdentity, EngineCore.LOGGER_TYPE_NAME);
+                        const instanceName = this.getInstanceName(instance);
+                        this.logInfo(core.I18n.formatMessage("engineCore.componentStarting", {
+                            element: instance.instanceType
+                        }));
+                        const componentState = this._context.state.componentStates[instanceName] ?? {};
+                        const lastState = core.ObjectHelper.clone(componentState);
+                        await instance.component.start(this._context.state.nodeIdentity, this._loggerTypeName, componentState);
+                        if (!core.ObjectHelper.equal(lastState, componentState)) {
+                            this._context.state.componentStates[instanceName] = componentState;
+                            this._context.stateDirty = true;
+                        }
                     }
                 }
                 this.logInfo(core.I18n.formatMessage("engineCore.componentsComplete"));
             }
+            this.logInfo(core.I18n.formatMessage("engineCore.started"));
+            this._isStarted = true;
+        }
+        catch (err) {
+            canContinue = false;
+            this.logError(core.BaseError.fromError(err));
+        }
+        finally {
+            if (!(await this.stateSave())) {
+                canContinue = false;
+            }
         }
-        this.logInfo(core.I18n.formatMessage("engineCore.started"));
+        return canContinue;
     }
     /**
      * Stop the engine core.
@@ -1300,9 +227,16 @@ class EngineCore {
         this.logInfo(core.I18n.formatMessage("engineCore.componentsStopping"));
         for (const instance of this._context.componentInstances) {
             if (core.Is.function(instance.component.stop)) {
+                const instanceName = this.getInstanceName(instance);
+                const componentState = this._context.state.componentStates[instanceName] ?? {};
+                const lastState = core.ObjectHelper.clone(componentState);
                 this.logInfo(core.I18n.formatMessage("engineCore.componentStopping", { element: instance.instanceType }));
                 try {
-                    await instance.component.stop(this._context.state.nodeIdentity, EngineCore.LOGGER_TYPE_NAME);
+                    await instance.component.stop(this._context.state.nodeIdentity, this._loggerTypeName, componentState);
+                    if (!core.ObjectHelper.equal(lastState, componentState)) {
+                        this._context.state.componentStates[instanceName] = componentState;
+                        this._context.stateDirty = true;
+                    }
                 }
                 catch (err) {
                     this.logError(new core.GeneralError(this.CLASS_NAME, "componentStopFailed", {
@@ -1311,6 +245,7 @@ class EngineCore {
                 }
             }
         }
+        await this.stateSave();
         this.logInfo(core.I18n.formatMessage("engineCore.componentsStopped"));
         this.logInfo(core.I18n.formatMessage("engineCore.stopped"));
     }
@@ -1366,14 +301,63 @@ class EngineCore {
     getDefaultTypes() {
         return this._context.defaultTypes;
     }
+    /**
+     * Get the data required to create a clone of the engine.
+     * @returns The clone data.
+     */
+    getCloneData() {
+        const entitySchemas = {};
+        const entitySchemaNames = entity.EntitySchemaFactory.names();
+        for (const schemaName of entitySchemaNames) {
+            entitySchemas[schemaName] = entity.EntitySchemaFactory.get(schemaName);
+        }
+        const cloneData = {
+            config: this._context.config,
+            state: this._context.state,
+            typeInitialisers: this._typeInitialisers,
+            entitySchemas,
+            loggerTypeName: this._loggerTypeName
+        };
+        return cloneData;
+    }
+    /**
+     * Populate the engine from the clone data.
+     * @param cloneData The clone data to populate from.
+     * @param silent Should the clone be silent.
+     */
+    populateClone(cloneData, silent) {
+        core.Guards.object(this.CLASS_NAME, "cloneData", cloneData);
+        core.Guards.object(this.CLASS_NAME, "cloneData.config", cloneData.config);
+        core.Guards.object(this.CLASS_NAME, "cloneData.state", cloneData.state);
+        core.Guards.array(this.CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
+        this._loggerTypeName = cloneData.loggerTypeName;
+        this._skipBootstrap = true;
+        if (silent ?? false) {
+            cloneData.config.silent = true;
+        }
+        this._context = {
+            config: cloneData.config,
+            defaultTypes: {},
+            componentInstances: [],
+            state: { componentStates: {} },
+            stateDirty: false
+        };
+        this._typeInitialisers = cloneData.typeInitialisers;
+        for (const schemaName of Object.keys(cloneData.entitySchemas)) {
+            entity.EntitySchemaFactory.register(schemaName, () => cloneData.entitySchemas[schemaName]);
+        }
+        this._stateStorage = new MemoryStateStorage(true, cloneData.state);
+        this._isStarted = false;
+    }
     /**
      * Initialise the types from connector.
      * @param typeKey The key for the default types.
      * @param instanceMethod The function to initialise the instance.
      * @internal
      */
-    initialiseTypeConfig(typeKey, typeConfig, instanceMethod) {
+    async initialiseTypeConfig(typeKey, typeConfig, module, method) {
         if (core.Is.arrayValue(typeConfig)) {
+            const instanceMethod = await modules.ModuleHelper.getModuleEntry(module, method);
             for (let i = 0; i < typeConfig.length; i++) {
                 const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
                 if (core.Is.stringValue(instanceType) &&
@@ -1388,21 +372,22 @@ class EngineCore {
      * @internal
      */
     setupEngineLogger() {
-        if (!this._context.config.silent) {
-            const engineLogger = new loggingConnectorConsole.ConsoleLoggingConnector({
+        const silent = this._context.config.silent ?? false;
+        const engineLogger = silent
+            ? new loggingModels.SilentLoggingConnector()
+            : new loggingConnectorConsole.ConsoleLoggingConnector({
                 config: {
                     translateMessages: true,
                     hideGroups: true
                 }
             });
-            this._context.componentInstances.push({
-                instanceType: EngineCore.LOGGER_TYPE_NAME,
-                component: engineLogger
-            });
-            loggingModels.LoggingConnectorFactory.register(EngineCore.LOGGER_TYPE_NAME, () => engineLogger);
-            this._engineLoggingConnector = engineLogger;
-            this._context.defaultTypes.loggingConnector = EngineCore.LOGGER_TYPE_NAME;
-        }
+        this._context.componentInstances.push({
+            instanceType: this._loggerTypeName,
+            component: engineLogger
+        });
+        loggingModels.LoggingConnectorFactory.register(this._loggerTypeName, () => engineLogger);
+        this._engineLoggingConnector = engineLogger;
+        this._context.defaultTypes.loggingConnector = this._loggerTypeName;
     }
     /**
      * Load the state.
@@ -1413,9 +398,9 @@ class EngineCore {
         if (this._stateStorage) {
             try {
                 this._context.state = ((await this._stateStorage.load(this)) ?? {
-                    bootstrappedComponents: []
+                    componentStates: {}
                 });
-                this._context.state.bootstrappedComponents ??= [];
+                this._context.state.componentStates ??= {};
                 this._context.stateDirty = false;
                 return true;
             }
@@ -1428,6 +413,7 @@ class EngineCore {
     }
     /**
      * Save the state.
+     * @returns True if the state was saved.
      * @internal
      */
     async stateSave() {
@@ -1435,90 +421,61 @@ class EngineCore {
             try {
                 await this._stateStorage.save(this, this._context.state);
                 this._context.stateDirty = false;
+                return true;
             }
             catch (err) {
                 this.logError(core.BaseError.fromError(err));
             }
+            return false;
         }
+        return true;
     }
     /**
      * Bootstrap the engine.
-     * @returns True if the engine can continue.
      * @internal
      */
     async bootstrap() {
-        let canContinue = true;
         if (!this._skipBootstrap) {
             this.logInfo(core.I18n.formatMessage("engineCore.bootstrapStarted"));
-            try {
-                // First bootstrap the components.
-                for (const instance of this._context.componentInstances) {
-                    if (core.Is.function(instance.component.bootstrap)) {
-                        const bootstrapName = `${instance.component.CLASS_NAME}-${instance.instanceType}`;
-                        if (!this._context.state.bootstrappedComponents.includes(bootstrapName)) {
-                            this.logInfo(core.I18n.formatMessage("engineCore.bootstrapping", {
-                                element: bootstrapName
-                            }));
-                            const bootstrapSuccess = await instance.component.bootstrap(EngineCore.LOGGER_TYPE_NAME);
-                            // If the bootstrap method failed then throw an error
-                            if (!bootstrapSuccess) {
-                                throw new core.GeneralError(this.CLASS_NAME, "bootstrapFailed", {
-                                    component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
-                                });
-                            }
-                            // Otherwise add the component to the bootstrapped list and set the state as dirty
-                            this._context.state.bootstrappedComponents.push(bootstrapName);
-                            this._context.stateDirty = true;
-                        }
+            // First bootstrap the components.
+            for (const instance of this._context.componentInstances) {
+                if (core.Is.function(instance.component.bootstrap)) {
+                    const instanceName = this.getInstanceName(instance);
+                    this.logInfo(core.I18n.formatMessage("engineCore.bootstrapping", {
+                        element: instanceName
+                    }));
+                    const componentState = this._context.state.componentStates[instanceName] ?? {};
+                    const lastState = core.ObjectHelper.clone(componentState);
+                    const bootstrapSuccess = await instance.component.bootstrap(this._loggerTypeName, componentState);
+                    // If the bootstrap method failed then throw an error
+                    if (!bootstrapSuccess) {
+                        throw new core.GeneralError(this.CLASS_NAME, "bootstrapFailed", {
+                            component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
+                        });
+                    }
+                    if (!core.ObjectHelper.equal(lastState, componentState)) {
+                        this._context.state.componentStates[instanceName] = componentState;
+                        this._context.stateDirty = true;
                     }
                 }
-                // Now perform any custom bootstrap operations
-                if (canContinue && core.Is.function(this._customBootstrap)) {
-                    await this._customBootstrap(this, this._context);
-                }
-            }
-            catch (err) {
-                canContinue = false;
-                this.logError(core.BaseError.fromError(err));
             }
-            finally {
-                await this.stateSave();
-                if (canContinue) {
-                    this.logInfo(core.I18n.formatMessage("engineCore.bootstrapComplete"));
-                }
+            // Now perform any custom bootstrap operations
+            if (core.Is.function(this._customBootstrap)) {
+                await this._customBootstrap(this, this._context);
             }
+            this.logInfo(core.I18n.formatMessage("engineCore.bootstrapComplete"));
         }
-        return canContinue;
     }
     /**
-     * Add the core type initializers.
+     * Get the instance name.
+     * @param instance The instance to get the name for.
+     * @param instance.instanceType The instance type.
+     * @param instance.component The component.
+     * @returns The instance name.
      * @internal
      */
-    addCoreTypeInitialisers() {
-        this.addTypeInitialiser("loggingConnector", this._context.config.loggingConnector, initialiseLoggingConnector);
-        this.addTypeInitialiser("loggingComponent", this._context.config.loggingComponent, initialiseLoggingComponent);
-        this.addTypeInitialiser("backgroundTaskConnector", this._context.config.backgroundTaskConnector, initialiseBackgroundTaskConnector);
-        this.addTypeInitialiser("telemetryConnector", this._context.config.telemetryConnector, initialiseTelemetryConnector);
-        this.addTypeInitialiser("telemetryComponent", this._context.config.telemetryComponent, initialiseTelemetryComponent);
-        this.addTypeInitialiser("entityStorageComponent", this._context.config.entityStorageComponent, initialiseEntityStorageComponent);
-        this.addTypeInitialiser("vaultConnector", this._context.config.vaultConnector, initialiseVaultConnector);
-        this.addTypeInitialiser("blobStorageConnector", this._context.config.blobStorageConnector, initialiseBlobStorageConnector);
-        this.addTypeInitialiser("blobStorageComponent", this._context.config.blobStorageComponent, initialiseBlobStorageComponent);
-        this.addTypeInitialiser("immutableStorageConnector", this._context.config.immutableStorageConnector, initialiseImmutableStorageConnector);
-        this.addTypeInitialiser("walletConnector", this._context.config.walletConnector, initialiseWalletStorage);
-        this.addTypeInitialiser("faucetConnector", this._context.config.faucetConnector, initialiseFaucetConnector);
-        this.addTypeInitialiser("walletConnector", this._context.config.walletConnector, initialiseWalletConnector);
-        this.addTypeInitialiser("identityConnector", this._context.config.identityConnector, initialiseIdentityConnector);
-        this.addTypeInitialiser("identityComponent", this._context.config.identityComponent, initialiseIdentityComponent);
-        this.addTypeInitialiser("identityProfileConnector", this._context.config.identityProfileConnector, initialiseIdentityProfileConnector);
-        this.addTypeInitialiser("identityProfileComponent", this._context.config.identityProfileComponent, initialiseIdentityProfileComponent);
-        this.addTypeInitialiser("nftConnector", this._context.config.nftConnector, initialiseNftConnector);
-        this.addTypeInitialiser("nftComponent", this._context.config.nftComponent, initialiseNftComponent);
-        this.addTypeInitialiser("immutableProofComponent", this._context.config.immutableProofComponent, initialiseImmutableProofComponent);
-        this.addTypeInitialiser("attestationConnector", this._context.config.attestationConnector, initialiseAttestationConnector);
-        this.addTypeInitialiser("attestationComponent", this._context.config.attestationComponent, initialiseAttestationComponent);
-        this.addTypeInitialiser("auditableItemGraphComponent", this._context.config.auditableItemGraphComponent, initialiseAuditableItemGraphComponent);
-        this.addTypeInitialiser("auditableItemStreamComponent", this._context.config.auditableItemStreamComponent, initialiseAuditableItemStreamComponent);
+    getInstanceName(instance) {
+        return `${instance.component.CLASS_NAME}-${instance.instanceType}`;
     }
 }
 
@@ -1583,6 +540,10 @@ class FileStateStorage {
                 engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
                     filename: this._filename
                 }));
+                try {
+                    await promises.mkdir(path.dirname(this._filename), { recursive: true });
+                }
+                catch { }
                 await promises.writeFile(this._filename, JSON.stringify(state, undefined, "\t"), "utf8");
             }
             catch (err) {
@@ -1607,586 +568,6 @@ class FileStateStorage {
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Store state in memory.
- */
-class MemoryStateStorage {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "MemoryStateStorage";
-    /**
-     * Readonly mode state file is not updated.
-     * @internal
-     */
-    _readonlyMode;
-    /**
-     * The state object.
-     * @internal
-     */
-    _engineState;
-    /**
-     * Create a new instance of MemoryStateStorage.
-     * @param readonlyMode Whether the file is in read-only mode.
-     */
-    constructor(readonlyMode = false) {
-        this._readonlyMode = readonlyMode;
-    }
-    /**
-     * Method for loading the state.
-     * @param engineCore The engine core to load the state for.
-     * @returns The state of the engine or undefined if it doesn't exist.
-     */
-    async load(engineCore) {
-        engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
-            filename: this._engineState
-        }));
-        return this._engineState;
-    }
-    /**
-     * Method for saving the state.
-     * @param engineCore The engine core to save the state for.
-     * @param state The state of the engine to save.
-     * @returns Nothing.
-     */
-    async save(engineCore, state) {
-        if (!this._readonlyMode) {
-            engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`));
-            this._engineState = state;
-        }
-    }
-}
-
-// 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.
- */
-function buildEngineCoreConfiguration(envVars) {
-    envVars.stateFilename ??= "engine-state.json";
-    envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
-    envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
-    envVars.attestationAssertionMethodId ??= "attestation-assertion";
-    envVars.immutableProofHashKeyId ??= "immutable-proof-hash";
-    envVars.immutableProofAssertionMethodId ??= "immutable-proof-assertion";
-    envVars.blobStorageEnableEncryption ??= "false";
-    envVars.blobStorageEncryptionKey ??= "blob-encryption";
-    const coreConfig = {
-        debug: core.Coerce.boolean(envVars.debug) ?? false,
-        loggingConnector: [],
-        loggingComponent: [{ type: engineModels.LoggingComponentType.Service }],
-        entityStorageConnector: [],
-        blobStorageConnector: [],
-        blobStorageComponent: [
-            {
-                type: engineModels.BlobStorageComponentType.Service,
-                options: {
-                    config: {
-                        vaultKeyId: envVars.blobStorageEncryptionKey
-                    }
-                }
-            }
-        ],
-        backgroundTaskConnector: [],
-        telemetryConnector: [],
-        telemetryComponent: [{ type: engineModels.TelemetryComponentType.Service }],
-        vaultConnector: [],
-        walletConnector: [],
-        faucetConnector: [],
-        immutableStorageConnector: [],
-        nftConnector: [],
-        nftComponent: [{ type: engineModels.NftComponentType.Service }],
-        identityConnector: [],
-        identityComponent: [{ type: engineModels.IdentityComponentType.Service }],
-        identityProfileConnector: [],
-        identityProfileComponent: [{ type: engineModels.IdentityProfileComponentType.Service }],
-        immutableProofComponent: [
-            {
-                type: engineModels.ImmutableProofComponentType.Service,
-                options: {
-                    config: {
-                        assertionMethodId: envVars.immutableProofAssertionMethodId,
-                        proofHashKeyId: envVars.immutableProofHashKeyId
-                    }
-                }
-            }
-        ],
-        attestationConnector: [],
-        attestationComponent: [
-            {
-                type: engineModels.AttestationComponentType.Service
-            }
-        ],
-        auditableItemGraphComponent: [{ type: engineModels.AuditableItemGraphComponentType.Service }],
-        auditableItemStreamComponent: [{ type: engineModels.AuditableItemStreamComponentType.Service }]
-    };
-    configureEntityStorageConnectors(coreConfig, envVars);
-    configureBlobStorageConnectors(coreConfig, envVars);
-    configureVaultConnectors(coreConfig, envVars);
-    configureLogging(coreConfig, envVars);
-    configureBackgroundTaskConnectors(coreConfig, envVars);
-    configureTelemetryConnectors(coreConfig, envVars);
-    configureFaucetConnectors(coreConfig, envVars);
-    configureWalletConnectors(coreConfig, envVars);
-    configureNftConnectors(coreConfig, envVars);
-    configureImmutableStorageConnectors(coreConfig, envVars);
-    configureIdentityConnectors(coreConfig, envVars);
-    configureIdentityProfileConnectors(coreConfig, envVars);
-    configureAttestationConnectors(coreConfig, envVars);
-    return coreConfig;
-}
-/**
- * Configures the entity storage connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureEntityStorageConnectors(coreConfig, envVars) {
-    coreConfig.entityStorageConnector ??= [];
-    if ((core.Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
-        envVars.blobStorageConnectorType === engineModels.EntityStorageConnectorType.Memory) {
-        coreConfig.entityStorageConnector.push({
-            type: engineModels.EntityStorageConnectorType.Memory
-        });
-    }
-    if ((core.Coerce.boolean(envVars.entityFileEnable) ?? false) ||
-        envVars.entityStorageConnectorType === engineModels.EntityStorageConnectorType.File) {
-        coreConfig.entityStorageConnector.push({
-            type: engineModels.EntityStorageConnectorType.File,
-            options: { config: { directory: envVars.storageFileRoot } }
-        });
-    }
-    if (core.Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
-        coreConfig.entityStorageConnector.push({
-            type: engineModels.EntityStorageConnectorType.AwsDynamoDb,
-            options: {
-                config: {
-                    region: envVars.awsDynamodbRegion,
-                    accessKeyId: envVars.awsDynamodbAccessKeyId,
-                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
-                    endpoint: envVars.awsDynamodbEndpoint
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.azureCosmosdbKey)) {
-        coreConfig.entityStorageConnector.push({
-            type: engineModels.EntityStorageConnectorType.AzureCosmosDb,
-            options: {
-                config: {
-                    endpoint: envVars.azureCosmosdbEndpoint,
-                    key: envVars.azureCosmosdbKey,
-                    databaseId: envVars.azureCosmosdbDatabaseId,
-                    containerId: envVars.azureCosmosdbContainerId
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.gcpFirestoreCredentials)) {
-        coreConfig.entityStorageConnector.push({
-            type: engineModels.EntityStorageConnectorType.GcpFirestoreDb,
-            options: {
-                config: {
-                    projectId: envVars.gcpFirestoreProjectId,
-                    credentials: envVars.gcpFirestoreCredentials,
-                    databaseId: envVars.gcpFirestoreDatabaseId,
-                    collectionName: envVars.gcpFirestoreCollectionName,
-                    endpoint: envVars.gcpFirestoreApiEndpoint
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.scylladbHosts)) {
-        coreConfig.entityStorageConnector.push({
-            type: engineModels.EntityStorageConnectorType.ScyllaDb,
-            options: {
-                config: {
-                    hosts: envVars.scylladbHosts.split(","),
-                    localDataCenter: envVars.scylladbLocalDataCenter,
-                    keyspace: envVars.scylladbKeyspace
-                },
-                tablePrefix: envVars.entityStorageTablePrefix
-            }
-        });
-    }
-    const defaultStorageConnector = envVars.entityStorageConnectorType;
-    if (core.Is.stringValue(defaultStorageConnector)) {
-        for (const config of coreConfig.entityStorageConnector) {
-            if (config.type === defaultStorageConnector) {
-                config.isDefault = true;
-            }
-        }
-    }
-}
-/**
- * Configures the blob storage connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureBlobStorageConnectors(coreConfig, envVars) {
-    coreConfig.blobStorageConnector ??= [];
-    if ((core.Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
-        envVars.blobStorageConnectorType === engineModels.BlobStorageConnectorType.Memory) {
-        coreConfig.blobStorageConnector.push({
-            type: engineModels.BlobStorageConnectorType.Memory
-        });
-    }
-    if ((core.Coerce.boolean(envVars.blobFileEnable) ?? false) ||
-        envVars.blobStorageConnectorType === engineModels.BlobStorageConnectorType.File) {
-        coreConfig.blobStorageConnector.push({
-            type: engineModels.BlobStorageConnectorType.File,
-            options: {
-                config: { directory: envVars.storageFileRoot },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.ipfsApiUrl)) {
-        coreConfig.blobStorageConnector.push({
-            type: engineModels.BlobStorageConnectorType.Ipfs,
-            options: {
-                config: {
-                    apiUrl: envVars.ipfsApiUrl,
-                    bearerToken: envVars.ipfsBearerToken
-                }
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.awsS3AccessKeyId)) {
-        coreConfig.blobStorageConnector.push({
-            type: engineModels.BlobStorageConnectorType.AwsS3,
-            options: {
-                config: {
-                    region: envVars.awsS3Region,
-                    bucketName: envVars.awsS3BucketName,
-                    accessKeyId: envVars.awsS3AccessKeyId,
-                    secretAccessKey: envVars.awsS3SecretAccessKey,
-                    endpoint: envVars.awsS3Endpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.azureStorageAccountKey)) {
-        coreConfig.blobStorageConnector.push({
-            type: engineModels.BlobStorageConnectorType.AzureStorage,
-            options: {
-                config: {
-                    accountName: envVars.azureStorageAccountName,
-                    accountKey: envVars.azureStorageAccountKey,
-                    containerName: envVars.azureStorageContainerName,
-                    endpoint: envVars.azureStorageEndpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    if (core.Is.stringValue(envVars.gcpStorageCredentials)) {
-        coreConfig.blobStorageConnector.push({
-            type: engineModels.BlobStorageConnectorType.GcpStorage,
-            options: {
-                config: {
-                    projectId: envVars.gcpStorageProjectId,
-                    credentials: envVars.gcpStorageCredentials,
-                    bucketName: envVars.gcpStorageBucketName,
-                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
-                },
-                storagePrefix: envVars.blobStoragePrefix
-            }
-        });
-    }
-    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
-    if (core.Is.stringValue(defaultStorageConnectorType)) {
-        for (const config of coreConfig.blobStorageConnector) {
-            if (config.type === defaultStorageConnectorType) {
-                config.isDefault = true;
-            }
-        }
-    }
-}
-/**
- * Configures the logging connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureLogging(coreConfig, envVars) {
-    const loggingConnectors = (envVars.loggingConnector ?? "").split(",");
-    for (const loggingConnector of loggingConnectors) {
-        if (loggingConnector === engineModels.LoggingConnectorType.Console) {
-            coreConfig.loggingConnector?.push({
-                type: engineModels.LoggingConnectorType.Console,
-                options: {
-                    config: {
-                        translateMessages: true,
-                        hideGroups: true
-                    }
-                }
-            });
-        }
-        else if (loggingConnector === engineModels.LoggingConnectorType.EntityStorage) {
-            coreConfig.loggingConnector?.push({
-                type: engineModels.LoggingConnectorType.EntityStorage
-            });
-        }
-    }
-    if (loggingConnectors.length > 1) {
-        coreConfig.loggingConnector?.push({
-            type: engineModels.LoggingConnectorType.Multi,
-            isDefault: true,
-            options: {
-                loggingConnectorTypes: loggingConnectors
-            }
-        });
-    }
-}
-/**
- * Configures the vault connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureVaultConnectors(coreConfig, envVars) {
-    coreConfig.vaultConnector ??= [];
-    if (envVars.vaultConnector === engineModels.VaultConnectorType.EntityStorage) {
-        coreConfig.vaultConnector.push({
-            type: engineModels.VaultConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.vaultConnector === engineModels.VaultConnectorType.Hashicorp) {
-        coreConfig.vaultConnector.push({
-            type: engineModels.VaultConnectorType.Hashicorp,
-            options: {
-                config: { endpoint: envVars.hashicorpVaultEndpoint, token: envVars.hashicorpVaultToken }
-            }
-        });
-    }
-}
-/**
- * Configures the background task connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureBackgroundTaskConnectors(coreConfig, envVars) {
-    coreConfig.backgroundTaskConnector ??= [];
-    if (envVars.backgroundTaskConnector === engineModels.BackgroundTaskConnectorType.EntityStorage) {
-        coreConfig.backgroundTaskConnector.push({
-            type: engineModels.BackgroundTaskConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the telemetry connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureTelemetryConnectors(coreConfig, envVars) {
-    coreConfig.telemetryConnector ??= [];
-    if (envVars.telemetryConnector === engineModels.TelemetryConnectorType.EntityStorage) {
-        coreConfig.telemetryConnector.push({
-            type: engineModels.TelemetryConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the faucet connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureFaucetConnectors(coreConfig, envVars) {
-    coreConfig.faucetConnector ??= [];
-    if (envVars.faucetConnector === engineModels.FaucetConnectorType.EntityStorage) {
-        coreConfig.faucetConnector.push({
-            type: engineModels.FaucetConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.faucetConnector === engineModels.FaucetConnectorType.Iota) {
-        coreConfig.faucetConnector.push({
-            type: engineModels.FaucetConnectorType.Iota,
-            options: {
-                config: {
-                    endpoint: envVars.iotaFaucetEndpoint,
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: core.Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the wallet connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureWalletConnectors(coreConfig, envVars) {
-    coreConfig.walletConnector ??= [];
-    if (envVars.walletConnector === engineModels.WalletConnectorType.EntityStorage) {
-        coreConfig.walletConnector.push({
-            type: engineModels.WalletConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.walletConnector === engineModels.WalletConnectorType.Iota) {
-        coreConfig.walletConnector.push({
-            type: engineModels.WalletConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: core.Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the NFT connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureNftConnectors(coreConfig, envVars) {
-    coreConfig.nftConnector ??= [];
-    if (envVars.nftConnector === engineModels.NftConnectorType.EntityStorage) {
-        coreConfig.nftConnector.push({
-            type: engineModels.NftConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.nftConnector === engineModels.NftConnectorType.Iota) {
-        coreConfig.nftConnector.push({
-            type: engineModels.NftConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: core.Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the immutable storage connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureImmutableStorageConnectors(coreConfig, envVars) {
-    coreConfig.immutableStorageConnector ??= [];
-    if (envVars.immutableStorageConnector === engineModels.ImmutableStorageConnectorType.EntityStorage) {
-        coreConfig.immutableStorageConnector.push({
-            type: engineModels.ImmutableStorageConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.immutableStorageConnector === engineModels.ImmutableStorageConnectorType.Iota) {
-        coreConfig.immutableStorageConnector.push({
-            type: engineModels.ImmutableStorageConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: core.Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the identity connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureIdentityConnectors(coreConfig, envVars) {
-    coreConfig.identityConnector ??= [];
-    if (envVars.identityConnector === engineModels.IdentityConnectorType.EntityStorage) {
-        coreConfig.identityConnector.push({
-            type: engineModels.IdentityConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.identityConnector === engineModels.IdentityConnectorType.Iota) {
-        coreConfig.identityConnector.push({
-            type: engineModels.IdentityConnectorType.Iota,
-            options: {
-                config: {
-                    clientOptions: {
-                        nodes: [envVars.iotaNodeEndpoint]
-                    },
-                    bech32Hrp: envVars.iotaBech32Hrp,
-                    coinType: core.Coerce.number(envVars.iotaCoinType)
-                }
-            }
-        });
-    }
-}
-/**
- * Configures the identity profile connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureIdentityProfileConnectors(coreConfig, envVars) {
-    coreConfig.identityProfileConnector ??= [];
-    if (envVars.identityProfileConnector === engineModels.IdentityConnectorType.EntityStorage) {
-        coreConfig.identityProfileConnector.push({
-            type: engineModels.IdentityProfileConnectorType.EntityStorage
-        });
-    }
-}
-/**
- * Configures the attestation connectors for the core.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- */
-function configureAttestationConnectors(coreConfig, envVars) {
-    coreConfig.attestationConnector ??= [];
-    if (envVars.attestationConnector === engineModels.AttestationConnectorType.EntityStorage) {
-        coreConfig.attestationConnector.push({
-            type: engineModels.AttestationConnectorType.EntityStorage
-        });
-    }
-    else if (envVars.attestationConnector === engineModels.AttestationConnectorType.Iota) {
-        coreConfig.attestationConnector.push({
-            type: engineModels.AttestationConnectorType.Iota
-        });
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Environment variable helper.
- */
-class EnvHelper {
-    /**
-     * Get the environment variable as an object with camel cased names.
-     * @param envVars The environment variables.
-     * @param prefix The prefix of the environment variables.
-     * @returns The object with camel cased names.
-     */
-    static envToJson(envVars, prefix) {
-        const result = {};
-        for (const envVar in envVars) {
-            if (envVar.startsWith(prefix) && core.Is.stringValue(process.env[envVar])) {
-                const camelCaseName = core.StringHelper.camelCase(envVar.replace(prefix, "").toLowerCase());
-                core.ObjectHelper.propertySet(result, camelCaseName, process.env[envVar]);
-            }
-        }
-        return result;
-    }
-}
-
 exports.EngineCore = EngineCore;
-exports.EnvHelper = EnvHelper;
 exports.FileStateStorage = FileStateStorage;
 exports.MemoryStateStorage = MemoryStateStorage;
-exports.buildEngineCoreConfiguration = buildEngineCoreConfiguration;
-exports.initialiseEntityStorageConnector = initialiseEntityStorageConnector;