@twin.org/engine-core 0.0.1-next.1

package/dist/cjs/index.cjs

@@ -0,0 +1,1662 @@
+'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 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 promises = require('node:fs/promises');
+
+// 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.
+ */
+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"
+        });
+    }
+    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");
+    }
+    else {
+        throw new core.GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "walletConnector"
+        });
+    }
+    return undefined;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Core for the engine.
+ */
+class EngineCore {
+    /**
+     * Name for the engine logger.
+     */
+    static LOGGER_TYPE_NAME = "engine";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "EngineCore";
+    /**
+     * The core context.
+     * @internal
+     */
+    _context;
+    /**
+     * The state storage interface.
+     * @internal
+     */
+    _stateStorage;
+    /**
+     * The logging connector for the engine.
+     * @internal
+     */
+    _engineLoggingConnector;
+    /**
+     * Skip the bootstrap process.
+     * @internal
+     */
+    _skipBootstrap;
+    /**
+     * The type initialisers.
+     * @internal
+     */
+    _typeInitialisers;
+    /**
+     * Method for bootstrapping any data for the engine.
+     * @internal
+     */
+    _customBootstrap;
+    /**
+     * Create a new instance of EngineCore.
+     * @param options The options for the engine.
+     */
+    constructor(options) {
+        options = options ?? {};
+        options.config = options.config ?? {};
+        options.config.debug = options.config.debug ?? false;
+        options.config.silent = options.config.silent ?? false;
+        this._skipBootstrap = options.skipBootstrap ?? false;
+        this._customBootstrap = options.customBootstrap;
+        this._typeInitialisers = [];
+        this._context = {
+            config: options.config,
+            defaultTypes: {},
+            componentInstances: [],
+            state: { bootstrappedComponents: [] },
+            stateDirty: false
+        };
+        this._stateStorage = options.stateStorage;
+        this.addCoreTypeInitialisers();
+    }
+    /**
+     * Add a type initialiser.
+     * @param type The type to add the initialiser for.
+     * @param typeConfig The type config.
+     * @param initialiser The initialiser to add.
+     */
+    addTypeInitialiser(type, typeConfig, initialiser) {
+        if (!core.Is.empty(typeConfig)) {
+            this._typeInitialisers.push({
+                type,
+                typeConfig,
+                initialiser: initialiser
+            });
+        }
+    }
+    /**
+     * Start the engine core.
+     * @returns Nothing.
+     */
+    async start() {
+        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();
+            if (canContinue) {
+                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);
+                    }
+                }
+                this.logInfo(core.I18n.formatMessage("engineCore.componentsComplete"));
+            }
+        }
+        this.logInfo(core.I18n.formatMessage("engineCore.started"));
+    }
+    /**
+     * Stop the engine core.
+     * @returns Nothing.
+     */
+    async stop() {
+        this.logInfo(core.I18n.formatMessage("engineCore.stopping"));
+        this.logInfo(core.I18n.formatMessage("engineCore.componentsStopping"));
+        for (const instance of this._context.componentInstances) {
+            if (core.Is.function(instance.component.stop)) {
+                this.logInfo(core.I18n.formatMessage("engineCore.componentStopping", { element: instance.instanceType }));
+                try {
+                    await instance.component.stop(this._context.state.nodeIdentity, EngineCore.LOGGER_TYPE_NAME);
+                }
+                catch (err) {
+                    this.logError(new core.GeneralError(this.CLASS_NAME, "componentStopFailed", {
+                        component: instance.instanceType
+                    }, core.BaseError.fromError(err)));
+                }
+            }
+        }
+        this.logInfo(core.I18n.formatMessage("engineCore.componentsStopped"));
+        this.logInfo(core.I18n.formatMessage("engineCore.stopped"));
+    }
+    /**
+     * Log info.
+     * @param message The message to log.
+     */
+    logInfo(message) {
+        this._engineLoggingConnector?.log({
+            source: this.CLASS_NAME,
+            level: "info",
+            message
+        });
+    }
+    /**
+     * Log error.
+     * @param error The error to log.
+     */
+    logError(error) {
+        const formattedErrors = core.ErrorHelper.localizeErrors(error);
+        for (const formattedError of formattedErrors) {
+            let message = core.Is.stringValue(formattedError.source)
+                ? `${formattedError.source}: ${formattedError.message}`
+                : formattedError.message;
+            if (this._context.config.debug && core.Is.stringValue(formattedError.stack)) {
+                message += `\n${formattedError.stack}`;
+            }
+            this._engineLoggingConnector?.log({
+                source: this.CLASS_NAME,
+                level: "error",
+                message
+            });
+        }
+    }
+    /**
+     * Get the config for the engine.
+     * @returns The config for the engine.
+     */
+    getConfig() {
+        return this._context.config;
+    }
+    /**
+     * Get the state of the engine.
+     * @returns The state of the engine.
+     */
+    getState() {
+        return this._context.state;
+    }
+    /**
+     * Get the types for the component.
+     * @returns The default types.
+     */
+    getDefaultTypes() {
+        return this._context.defaultTypes;
+    }
+    /**
+     * 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) {
+        if (core.Is.arrayValue(typeConfig)) {
+            for (let i = 0; i < typeConfig.length; i++) {
+                const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
+                if (core.Is.stringValue(instanceType) &&
+                    (core.Is.empty(this._context.defaultTypes[typeKey]) || typeConfig[i].isDefault)) {
+                    this._context.defaultTypes[typeKey] = instanceType;
+                }
+            }
+        }
+    }
+    /**
+     * Setup the engine logger.
+     * @internal
+     */
+    setupEngineLogger() {
+        if (!this._context.config.silent) {
+            const engineLogger = 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;
+        }
+    }
+    /**
+     * Load the state.
+     * @returns True if the state was loaded and can continue.
+     * @internal
+     */
+    async stateLoad() {
+        if (this._stateStorage) {
+            try {
+                this._context.state = (await this._stateStorage.load(this)) ?? {
+                    bootstrappedComponents: []
+                };
+                this._context.state.bootstrappedComponents ??= [];
+                this._context.stateDirty = false;
+                return true;
+            }
+            catch (err) {
+                this.logError(core.BaseError.fromError(err));
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Save the state.
+     * @internal
+     */
+    async stateSave() {
+        if (this._stateStorage && !core.Is.empty(this._context.state) && this._context.stateDirty) {
+            try {
+                await this._stateStorage.save(this, this._context.state);
+                this._context.stateDirty = false;
+            }
+            catch (err) {
+                this.logError(core.BaseError.fromError(err));
+            }
+        }
+    }
+    /**
+     * 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.
+                if (core.Is.arrayValue(this._context.state?.bootstrappedComponents)) {
+                    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;
+                            }
+                        }
+                    }
+                    // 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"));
+                }
+            }
+        }
+        return canContinue;
+    }
+    /**
+     * Add the core type initializers.
+     * @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);
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Store state in a file.
+ */
+class FileStateStorage {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "FileStateStorage";
+    /**
+     * The filename to store the state.
+     * @internal
+     */
+    _filename;
+    /**
+     * Readonly mode state file is not updated.
+     * @internal
+     */
+    _readonlyMode;
+    /**
+     * Create a new instance of FileStateStorage.
+     * @param filename The filename to store the state.
+     * @param readonlyMode Whether the file is in read-only mode.
+     */
+    constructor(filename, readonlyMode = false) {
+        core.Guards.stringValue(this.CLASS_NAME, "filename", filename);
+        this._filename = filename;
+        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) {
+        try {
+            engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
+                filename: this._filename
+            }));
+            if (await this.fileExists(this._filename)) {
+                const content = await promises.readFile(this._filename, "utf8");
+                return JSON.parse(content.toString());
+            }
+        }
+        catch (err) {
+            throw new core.GeneralError(this.CLASS_NAME, "loadingError", { filename: this._filename }, core.BaseError.fromError(err));
+        }
+    }
+    /**
+     * 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) {
+            try {
+                engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
+                    filename: this._filename
+                }));
+                await promises.writeFile(this._filename, JSON.stringify(state), "utf8");
+            }
+            catch (err) {
+                throw new core.GeneralError(this.CLASS_NAME, "savingError", { filename: this._filename }, core.BaseError.fromError(err));
+            }
+        }
+    }
+    /**
+     * Does the specified file exist.
+     * @param filename The filename to check for existence.
+     * @returns True if the file exists.
+     * @internal
+     */
+    async fileExists(filename) {
+        try {
+            const stats = await promises.stat(filename);
+            return stats.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+// 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;