@twin.org/engine-core 0.0.1-next.3 → 0.0.1-next.30

package/dist/cjs/index.cjs

@@ -1,1180 +1,65 @@
 'use strict';
 
 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
-        });
-    }
-    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.
@@ -1193,7 +78,6 @@ class EngineCore {
     CLASS_NAME = "EngineCore";
     /**
      * The core context.
-     * @internal
      */
     _context;
     /**
@@ -1211,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
@@ -1230,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: { bootstrappedComponents: [], 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));
         }
-        this.logInfo(core.I18n.formatMessage("engineCore.started"));
+        finally {
+            if (!(await this.stateSave())) {
+                canContinue = false;
+            }
+        }
+        return canContinue;
     }
     /**
      * Stop the engine core.
@@ -1295,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", {
@@ -1306,6 +245,7 @@ class EngineCore {
                 }
             }
         }
+        await this.stateSave();
         this.logInfo(core.I18n.formatMessage("engineCore.componentsStopped"));
         this.logInfo(core.I18n.formatMessage("engineCore.stopped"));
     }
@@ -1361,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: { bootstrappedComponents: [], 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) &&
@@ -1383,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.
@@ -1408,9 +398,11 @@ class EngineCore {
         if (this._stateStorage) {
             try {
                 this._context.state = ((await this._stateStorage.load(this)) ?? {
-                    bootstrappedComponents: []
+                    bootstrappedComponents: [],
+                    componentStates: {}
                 });
                 this._context.state.bootstrappedComponents ??= [];
+                this._context.state.componentStates ??= {};
                 this._context.stateDirty = false;
                 return true;
             }
@@ -1423,6 +415,7 @@ class EngineCore {
     }
     /**
      * Save the state.
+     * @returns True if the state was saved.
      * @internal
      */
     async stateSave() {
@@ -1430,90 +423,65 @@ 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 = `component-${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);
+                    if (!this._context.state.bootstrappedComponents.includes(instanceName)) {
+                        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}`
+                            });
+                        }
+                        // Otherwise add the component to the bootstrapped list and set the state as dirty
+                        this._context.state.bootstrappedComponents.push(instanceName);
+                        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}`;
     }
 }
 
@@ -1578,7 +546,11 @@ class FileStateStorage {
                 engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
                     filename: this._filename
                 }));
-                await promises.writeFile(this._filename, JSON.stringify(state, null, 2), "utf8");
+                try {
+                    await promises.mkdir(path.dirname(this._filename), { recursive: true });
+                }
+                catch { }
+                await promises.writeFile(this._filename, JSON.stringify(state, undefined, "\t"), "utf8");
             }
             catch (err) {
                 throw new core.GeneralError(this.CLASS_NAME, "savingError", { filename: this._filename }, core.BaseError.fromError(err));
@@ -1602,59 +574,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;
-        }
-    }
-}
-
 exports.EngineCore = EngineCore;
 exports.FileStateStorage = FileStateStorage;
 exports.MemoryStateStorage = MemoryStateStorage;
-exports.initialiseEntityStorageConnector = initialiseEntityStorageConnector;