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

package/dist/esm/index.mjs

@@ -0,0 +1,1657 @@
+import { StringHelper, Is, GeneralError, I18n, ComponentFactory, BaseError, ErrorHelper, Guards } from '@twin.org/core';
+import { EntityStorageConnectorType, EntityStorageComponentType, AttestationConnectorType, AttestationComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, BackgroundTaskConnectorType, BlobStorageConnectorType, BlobStorageComponentType, FaucetConnectorType, IdentityConnectorType, IdentityComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, ImmutableProofComponentType, ImmutableStorageConnectorType, LoggingConnectorType, LoggingComponentType, NftConnectorType, NftComponentType, TelemetryConnectorType, TelemetryComponentType, VaultConnectorType, WalletConnectorType } from '@twin.org/engine-models';
+import { CosmosDbEntityStorageConnector } from '@twin.org/entity-storage-connector-cosmosdb';
+import { DynamoDbEntityStorageConnector } from '@twin.org/entity-storage-connector-dynamodb';
+import { FileEntityStorageConnector } from '@twin.org/entity-storage-connector-file';
+import { FirestoreEntityStorageConnector } from '@twin.org/entity-storage-connector-gcp-firestore';
+import { MemoryEntityStorageConnector } from '@twin.org/entity-storage-connector-memory';
+import { ScyllaDBTableConnector } from '@twin.org/entity-storage-connector-scylladb';
+import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
+import { EntityStorageService } from '@twin.org/entity-storage-service';
+import { ConsoleLoggingConnector } from '@twin.org/logging-connector-console';
+import { MultiLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
+import { EntityStorageAttestationConnector } from '@twin.org/attestation-connector-entity-storage';
+import { IotaAttestationConnector } from '@twin.org/attestation-connector-iota';
+import { AttestationConnectorFactory } from '@twin.org/attestation-models';
+import { AttestationService } from '@twin.org/attestation-service';
+import { initSchema, AuditableItemGraphService } from '@twin.org/auditable-item-graph-service';
+import { initSchema as initSchema$1, AuditableItemStreamService } from '@twin.org/auditable-item-stream-service';
+import { initSchema as initSchema$2, EntityStorageBackgroundTaskConnector } from '@twin.org/background-task-connector-entity-storage';
+import { BackgroundTaskConnectorFactory } from '@twin.org/background-task-models';
+import { S3BlobStorageConnector } from '@twin.org/blob-storage-connector-aws-s3';
+import { AzureBlobStorageConnector } from '@twin.org/blob-storage-connector-azure';
+import { FileBlobStorageConnector } from '@twin.org/blob-storage-connector-file';
+import { GcpBlobStorageConnector } from '@twin.org/blob-storage-connector-gcp';
+import { IpfsBlobStorageConnector } from '@twin.org/blob-storage-connector-ipfs';
+import { MemoryBlobStorageConnector } from '@twin.org/blob-storage-connector-memory';
+import { BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
+import { initSchema as initSchema$3, BlobStorageService } from '@twin.org/blob-storage-service';
+import { EntityStorageFaucetConnector, EntityStorageWalletConnector, initSchema as initSchema$b } from '@twin.org/wallet-connector-entity-storage';
+import { IotaFaucetConnector, IotaWalletConnector } from '@twin.org/wallet-connector-iota';
+import { FaucetConnectorFactory, WalletConnectorFactory } from '@twin.org/wallet-models';
+import { initSchema as initSchema$4, EntityStorageIdentityConnector, EntityStorageIdentityProfileConnector } from '@twin.org/identity-connector-entity-storage';
+import { IotaIdentityConnector } from '@twin.org/identity-connector-iota';
+import { IdentityConnectorFactory, IdentityProfileConnectorFactory } from '@twin.org/identity-models';
+import { IdentityService, IdentityProfileService } from '@twin.org/identity-service';
+import { initSchema as initSchema$5, ImmutableProofService } from '@twin.org/immutable-proof-service';
+import { initSchema as initSchema$6, EntityStorageImmutableStorageConnector } from '@twin.org/immutable-storage-connector-entity-storage';
+import { IotaImmutableStorageConnector } from '@twin.org/immutable-storage-connector-iota';
+import { ImmutableStorageConnectorFactory } from '@twin.org/immutable-storage-models';
+import { initSchema as initSchema$7, EntityStorageLoggingConnector } from '@twin.org/logging-connector-entity-storage';
+import { LoggingService } from '@twin.org/logging-service';
+import { initSchema as initSchema$8, EntityStorageNftConnector } from '@twin.org/nft-connector-entity-storage';
+import { IotaNftConnector } from '@twin.org/nft-connector-iota';
+import { NftConnectorFactory } from '@twin.org/nft-models';
+import { NftService } from '@twin.org/nft-service';
+import { initSchema as initSchema$9, EntityStorageTelemetryConnector } from '@twin.org/telemetry-connector-entity-storage';
+import { TelemetryConnectorFactory } from '@twin.org/telemetry-models';
+import { TelemetryService } from '@twin.org/telemetry-service';
+import { initSchema as initSchema$a, EntityStorageVaultConnector } from '@twin.org/vault-connector-entity-storage';
+import { HashicorpVaultConnector } from '@twin.org/vault-connector-hashicorp';
+import { VaultConnectorFactory } from '@twin.org/vault-models';
+import { readFile, writeFile, stat } from '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 = StringHelper.kebabCase(schema);
+    let entityStorageConfig;
+    if (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 (Is.empty(entityStorageConfig)) {
+            throw new 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 (Is.empty(entityStorageConfig)) {
+            throw new GeneralError("engineCore", "entityStorageMissing", {
+                storageName: instanceName
+            });
+        }
+    }
+    const type = entityStorageConfig.type;
+    let entityStorageConnector;
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuringEntityStorage", {
+        element: "Entity Storage",
+        storageName: instanceName,
+        storageType: type
+    }));
+    if (type === EntityStorageConnectorType.Memory) {
+        entityStorageConnector = new MemoryEntityStorageConnector({
+            entitySchema: schema
+        });
+    }
+    else if (type === EntityStorageConnectorType.File) {
+        entityStorageConnector = new FileEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options
+        });
+    }
+    else if (type === EntityStorageConnectorType.AwsDynamoDb) {
+        entityStorageConnector = new DynamoDbEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.AzureCosmosDb) {
+        entityStorageConnector = new CosmosDbEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                containerId: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.GcpFirestoreDb) {
+        entityStorageConnector = new FirestoreEntityStorageConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                collectionName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else if (type === EntityStorageConnectorType.ScyllaDb) {
+        entityStorageConnector = new ScyllaDBTableConnector({
+            entitySchema: schema,
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                tableName: `${entityStorageConfig.options.tablePrefix ?? ""}${instanceName}`
+            }
+        });
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "entityStorageConnector"
+        });
+    }
+    context.componentInstances.push({
+        instanceType: instanceName,
+        component: entityStorageConnector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Entity Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === EntityStorageComponentType.Service) {
+        const kebabName = 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({
+            entityStorageType: kebabName,
+            config: {
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = StringHelper.kebabCase(instanceConfig.options.entityStorageType);
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            serviceType: "entityStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Attestation Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === AttestationConnectorType.Iota) {
+        connector = new IotaAttestationConnector({
+            identityConnectorType: context.defaultTypes.identityConnector,
+            nftConnectorType: context.defaultTypes.nftConnector,
+            ...instanceConfig.options
+        });
+        instanceType = IotaAttestationConnector.NAMESPACE;
+    }
+    else if (type === AttestationConnectorType.EntityStorage) {
+        connector = new EntityStorageAttestationConnector({
+            identityConnectorType: context.defaultTypes.identityConnector,
+            nftConnectorType: context.defaultTypes.nftConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageAttestationConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "attestationConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Attestation Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AttestationComponentType.Service) {
+        component = new AttestationService({
+            walletConnectorType: context.defaultTypes.walletConnector,
+            ...instanceConfig.options
+        });
+        instanceType = AttestationService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "attestationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Auditable Item Graph Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AuditableItemGraphComponentType.Service) {
+        initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vertexEntityStorageType, "AuditableItemGraphVertex");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.changesetEntityStorageType, "AuditableItemGraphChangeset");
+        component = new AuditableItemGraphService({
+            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
+            ...instanceConfig.options
+        });
+        instanceType = AuditableItemGraphService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "auditableItemGraphComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Auditable Item Stream Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AuditableItemStreamComponentType.Service) {
+        initSchema$1();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntityStorageType, "AuditableItemStream");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.streamEntryEntityStorageType, "AuditableItemStreamEntry");
+        component = new AuditableItemStreamService({
+            immutableProofComponentType: context.defaultTypes.immutableProofComponent,
+            ...instanceConfig.options
+        });
+        instanceType = AuditableItemStreamService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "auditableItemStreamComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Background Task Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === BackgroundTaskConnectorType.EntityStorage) {
+        initSchema$2();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.backgroundTaskEntityStorageType, "BackgroundTask");
+        connector = new EntityStorageBackgroundTaskConnector({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageBackgroundTaskConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "backgroundTaskConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Blob Storage Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === BlobStorageConnectorType.Ipfs) {
+        connector = new IpfsBlobStorageConnector(instanceConfig.options);
+        instanceType = IpfsBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.File) {
+        connector = new FileBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                directory: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.directory}`
+            }
+        });
+        instanceType = FileBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.Memory) {
+        connector = new MemoryBlobStorageConnector();
+        instanceType = MemoryBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.AwsS3) {
+        connector = new S3BlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
+            }
+        });
+        instanceType = S3BlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.GcpStorage) {
+        connector = new GcpBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                bucketName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.bucketName}`
+            }
+        });
+        instanceType = GcpBlobStorageConnector.NAMESPACE;
+    }
+    else if (type === BlobStorageConnectorType.AzureStorage) {
+        connector = new AzureBlobStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...instanceConfig.options.config,
+                containerName: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.containerName}`
+            }
+        });
+        instanceType = AzureBlobStorageConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "blobStorageConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Blob Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === BlobStorageComponentType.Service) {
+        initSchema$3();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.entryEntityStorageType, "BlobStorageEntry");
+        component = new BlobStorageService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = BlobStorageService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "blobStorageComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Faucet Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === FaucetConnectorType.Iota) {
+        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new IotaFaucetConnector({
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaFaucetConnector.NAMESPACE;
+    }
+    else if (type === FaucetConnectorType.EntityStorage) {
+        connector = new EntityStorageFaucetConnector(instanceConfig.options);
+        instanceType = EntityStorageFaucetConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "faucetConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === IdentityConnectorType.Iota) {
+        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new IotaIdentityConnector({
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaIdentityConnector.NAMESPACE;
+    }
+    else if (type === IdentityConnectorType.EntityStorage) {
+        initSchema$4({ includeProfile: false });
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.didDocumentEntityStorageType, "IdentityDocument");
+        connector = new EntityStorageIdentityConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageIdentityConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "identityConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === IdentityComponentType.Service) {
+        component = new IdentityService(instanceConfig.options);
+        instanceType = IdentityService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "identityComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Profile Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === IdentityProfileConnectorType.EntityStorage) {
+        initSchema$4({ includeDocument: false });
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.profileEntityStorageType, "IdentityProfile");
+        connector = new EntityStorageIdentityProfileConnector(instanceConfig.options);
+        instanceType = EntityStorageIdentityProfileConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            serviceType: "identityProfile"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Identity Profile Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === IdentityProfileComponentType.Service) {
+        component = new IdentityProfileService({
+            profileEntityConnectorType: context.defaultTypes.identityProfileConnector,
+            ...instanceConfig.options
+        });
+        instanceType = IdentityProfileService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "identityProfileComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Immutable Proof Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === ImmutableProofComponentType.Service) {
+        initSchema$5();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableProofEntityStorageType, "ImmutableProof");
+        component = new ImmutableProofService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            immutableStorageType: context.defaultTypes.immutableStorageConnector,
+            identityConnectorType: context.defaultTypes.identityConnector,
+            backgroundTaskConnectorType: context.defaultTypes.backgroundTaskConnector,
+            ...instanceConfig.options
+        });
+        instanceType = ImmutableProofService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "immutableProofComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Immutable Storage Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === ImmutableStorageConnectorType.Iota) {
+        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new IotaImmutableStorageConnector({
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaImmutableStorageConnector.NAMESPACE;
+    }
+    else if (type === ImmutableStorageConnectorType.EntityStorage) {
+        initSchema$6();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.immutableStorageEntityStorageType, "ImmutableItem");
+        connector = new EntityStorageImmutableStorageConnector(instanceConfig.options);
+        instanceType = EntityStorageImmutableStorageConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "immutableStorageConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Logging Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === LoggingConnectorType.Console) {
+        connector = new ConsoleLoggingConnector(instanceConfig.options);
+        instanceType = ConsoleLoggingConnector.NAMESPACE;
+    }
+    else if (type === LoggingConnectorType.EntityStorage) {
+        initSchema$7();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.logEntryStorageConnectorType, "LogEntry");
+        connector = new EntityStorageLoggingConnector(instanceConfig.options);
+        instanceType = EntityStorageLoggingConnector.NAMESPACE;
+    }
+    else if (type === LoggingConnectorType.Multi) {
+        connector = new MultiLoggingConnector(instanceConfig.options);
+        instanceType = MultiLoggingConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "loggingConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Logging Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === LoggingComponentType.Service) {
+        component = new LoggingService({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = LoggingService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "loggingComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `NFT Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === NftConnectorType.EntityStorage) {
+        initSchema$8();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.nftEntityStorageType, "Nft");
+        connector = new EntityStorageNftConnector(instanceConfig.options);
+        instanceType = EntityStorageNftConnector.NAMESPACE;
+    }
+    else if (type === NftConnectorType.Iota) {
+        connector = new IotaNftConnector({
+            ...instanceConfig.options
+        });
+        instanceType = IotaNftConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "nftConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Nft Storage Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === NftComponentType.Service) {
+        component = new NftService(instanceConfig.options);
+        instanceType = NftService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "nftComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Telemetry Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === TelemetryConnectorType.EntityStorage) {
+        initSchema$9();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricStorageConnectorType, "TelemetryMetric");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.telemetryMetricValueStorageConnectorType, "TelemetryMetricValue");
+        connector = new EntityStorageTelemetryConnector({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageTelemetryConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "telemetryConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Telemetry Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === TelemetryComponentType.Service) {
+        component = new TelemetryService({
+            telemetryConnectorType: context.defaultTypes.telemetryConnector,
+            ...instanceConfig.options
+        });
+        instanceType = TelemetryService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "telemetryComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Vault Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === VaultConnectorType.EntityStorage) {
+        initSchema$a();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultKeyEntityStorageType, "VaultKey");
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.vaultSecretEntityStorageType, "VaultSecret");
+        connector = new EntityStorageVaultConnector(instanceConfig.options);
+        instanceType = EntityStorageVaultConnector.NAMESPACE;
+    }
+    else if (type === VaultConnectorType.Hashicorp) {
+        connector = new HashicorpVaultConnector(instanceConfig.options);
+        instanceType = HashicorpVaultConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "vaultConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({ instanceType: finalInstanceType, component: connector });
+    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(I18n.formatMessage("engineCore.configuring", {
+        element: `Wallet Connector: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let connector;
+    let instanceType;
+    if (type === WalletConnectorType.Iota) {
+        const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
+        connector = new IotaWalletConnector({
+            ...instanceConfig.options,
+            config: {
+                ...dltConfig?.options?.config,
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = IotaWalletConnector.NAMESPACE;
+    }
+    else if (type === WalletConnectorType.EntityStorage) {
+        connector = new EntityStorageWalletConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            faucetConnectorType: context.defaultTypes.faucetConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageWalletConnector.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "connectorUnknownType", {
+            type,
+            connectorType: "walletConnector"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component: connector
+    });
+    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 === WalletConnectorType.Iota) ;
+    else if (type === WalletConnectorType.EntityStorage) {
+        initSchema$b();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.walletAddressEntityStorageType, "WalletAddress");
+    }
+    else {
+        throw new 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 (!Is.empty(typeConfig)) {
+            this._typeInitialisers.push({
+                type,
+                typeConfig,
+                initialiser: initialiser
+            });
+        }
+    }
+    /**
+     * Start the engine core.
+     * @returns Nothing.
+     */
+    async start() {
+        this.setupEngineLogger();
+        this.logInfo(I18n.formatMessage("engineCore.starting"));
+        if (this._context.config.debug) {
+            this.logInfo(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(I18n.formatMessage("engineCore.componentsStarting"));
+                for (const instance of this._context.componentInstances) {
+                    if (Is.function(instance.component.start)) {
+                        this.logInfo(I18n.formatMessage("engineCore.componentStarting", { element: instance.instanceType }));
+                        await instance.component.start(this._context.state.nodeIdentity, EngineCore.LOGGER_TYPE_NAME);
+                    }
+                }
+                this.logInfo(I18n.formatMessage("engineCore.componentsComplete"));
+            }
+        }
+        this.logInfo(I18n.formatMessage("engineCore.started"));
+    }
+    /**
+     * Stop the engine core.
+     * @returns Nothing.
+     */
+    async stop() {
+        this.logInfo(I18n.formatMessage("engineCore.stopping"));
+        this.logInfo(I18n.formatMessage("engineCore.componentsStopping"));
+        for (const instance of this._context.componentInstances) {
+            if (Is.function(instance.component.stop)) {
+                this.logInfo(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 GeneralError(this.CLASS_NAME, "componentStopFailed", {
+                        component: instance.instanceType
+                    }, BaseError.fromError(err)));
+                }
+            }
+        }
+        this.logInfo(I18n.formatMessage("engineCore.componentsStopped"));
+        this.logInfo(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 = ErrorHelper.localizeErrors(error);
+        for (const formattedError of formattedErrors) {
+            let message = Is.stringValue(formattedError.source)
+                ? `${formattedError.source}: ${formattedError.message}`
+                : formattedError.message;
+            if (this._context.config.debug && 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 (Is.arrayValue(typeConfig)) {
+            for (let i = 0; i < typeConfig.length; i++) {
+                const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
+                if (Is.stringValue(instanceType) &&
+                    (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 ConsoleLoggingConnector({
+                config: {
+                    translateMessages: true,
+                    hideGroups: true
+                }
+            });
+            this._context.componentInstances.push({
+                instanceType: EngineCore.LOGGER_TYPE_NAME,
+                component: engineLogger
+            });
+            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(BaseError.fromError(err));
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Save the state.
+     * @internal
+     */
+    async stateSave() {
+        if (this._stateStorage && !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(BaseError.fromError(err));
+            }
+        }
+    }
+    /**
+     * Bootstrap the engine.
+     * @returns True if the engine can continue.
+     * @internal
+     */
+    async bootstrap() {
+        let canContinue = true;
+        if (!this._skipBootstrap) {
+            this.logInfo(I18n.formatMessage("engineCore.bootstrapStarted"));
+            try {
+                // First bootstrap the components.
+                if (Is.arrayValue(this._context.state?.bootstrappedComponents)) {
+                    for (const instance of this._context.componentInstances) {
+                        if (Is.function(instance.component.bootstrap)) {
+                            const bootstrapName = `component-${instance.component.CLASS_NAME}-${instance.instanceType}`;
+                            if (!this._context.state.bootstrappedComponents.includes(bootstrapName)) {
+                                this.logInfo(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 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 && Is.function(this._customBootstrap)) {
+                        await this._customBootstrap(this, this._context);
+                    }
+                }
+            }
+            catch (err) {
+                canContinue = false;
+                this.logError(BaseError.fromError(err));
+            }
+            finally {
+                await this.stateSave();
+                if (canContinue) {
+                    this.logInfo(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) {
+        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(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
+                filename: this._filename
+            }));
+            if (await this.fileExists(this._filename)) {
+                const content = await readFile(this._filename, "utf8");
+                return JSON.parse(content.toString());
+            }
+        }
+        catch (err) {
+            throw new GeneralError(this.CLASS_NAME, "loadingError", { filename: this._filename }, 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(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
+                    filename: this._filename
+                }));
+                await writeFile(this._filename, JSON.stringify(state), "utf8");
+            }
+            catch (err) {
+                throw new GeneralError(this.CLASS_NAME, "savingError", { filename: this._filename }, 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 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(I18n.formatMessage(`${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(I18n.formatMessage(`${StringHelper.camelCase(this.CLASS_NAME)}.saving`));
+            this._engineState = state;
+        }
+    }
+}
+
+export { EngineCore, FileStateStorage, MemoryStateStorage, initialiseEntityStorageConnector };