@twin.org/immutable-proof-service 0.0.1-next.2 → 0.0.1-next.20

package/dist/esm/index.mjs

@@ -1,16 +1,83 @@
-import { Guards, ComponentFactory, StringHelper, Validation, Converter, RandomHelper, ObjectHelper, Urn, GeneralError, Is, NotFoundError, JsonHelper } from '@twin.org/core';
-import { ImmutableProofTypes, ImmutableProofFailure } from '@twin.org/immutable-proof-models';
-import { DidContexts, DidTypes, DidCryptoSuites } from '@twin.org/standards-w3c-did';
+import { property, SortDirection, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
+import { Guards, ComponentFactory, StringHelper, Is, Validation, Converter, RandomHelper, ObjectHelper, Urn, GeneralError, NotFoundError, JsonHelper } from '@twin.org/core';
+import { ImmutableProofTypes, ImmutableProofFailure, ImmutableProofTopics } from '@twin.org/immutable-proof-models';
+import { DidCryptoSuites, DidTypes, DidContexts } from '@twin.org/standards-w3c-did';
 import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
+import { BackgroundTaskConnectorFactory, TaskStatus } from '@twin.org/background-task-models';
 import { Blake2b, Sha256 } from '@twin.org/crypto';
 import { JsonLdHelper, JsonLdProcessor } from '@twin.org/data-json-ld';
-import { SchemaOrgDataTypes, SchemaOrgTypes } from '@twin.org/data-schema-org';
-import { ComparisonOperator, SortDirection, property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { IdentityConnectorFactory } from '@twin.org/identity-models';
-import { ImmutableStorageConnectorFactory } from '@twin.org/immutable-storage-models';
+import { ImmutableStorageConnectorFactory, ImmutableStorageTypes } from '@twin.org/immutable-storage-models';
 import { VaultConnectorFactory } from '@twin.org/vault-models';
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the immutable proof.
+ */
+let ImmutableProof = class ImmutableProof {
+    /**
+     * The id of the proof.
+     */
+    id;
+    /**
+     * The identity of the node which controls the proof.
+     */
+    nodeIdentity;
+    /**
+     * The identity of the user which created the proof.
+     */
+    userIdentity;
+    /**
+     * The date/time of when the proof was created.
+     */
+    dateCreated;
+    /**
+     * The associated id for the item.
+     */
+    proofObjectId;
+    /**
+     * The associated hash for the item.
+     */
+    proofObjectHash;
+    /**
+     * The immutable storage id.
+     */
+    immutableStorageId;
+};
+__decorate([
+    property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "id", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "nodeIdentity", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "userIdentity", void 0);
+__decorate([
+    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "dateCreated", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "proofObjectId", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "proofObjectHash", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], ImmutableProof.prototype, "immutableStorageId", void 0);
+ImmutableProof = __decorate([
+    entity()
+], ImmutableProof);
+
 /**
  * The source used when communicating about these routes.
  */
@@ -46,7 +113,7 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     request: {
                         body: {
                             proofObject: {
-                                "@context": "http://schema.org",
+                                "@context": "https://schema.org",
                                 type: "Person",
                                 name: "John Smith"
                             }
@@ -164,8 +231,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
         operationId: "immutableProofVerify",
         summary: "Verify a proof",
         tag: tagsImmutableProof[0].name,
-        method: "POST",
-        path: `${baseRouteName}/:id`,
+        method: "GET",
+        path: `${baseRouteName}/:id/verify`,
         handler: async (httpRequestContext, request) => immutableProofVerify(httpRequestContext, componentName, request),
         requestType: {
             type: "IImmutableProofVerifyRequest",
@@ -175,13 +242,6 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     request: {
                         pathParams: {
                             id: "ais:1234567890"
-                        },
-                        body: {
-                            proofObject: {
-                                "@context": "http://schema.org",
-                                type: "Person",
-                                name: "John Smith"
-                            }
                         }
                     }
                 }
@@ -277,10 +337,9 @@ async function immutableProofVerify(httpRequestContext, componentName, request)
     Guards.object(ROUTES_SOURCE, "request", request);
     Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
     Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const component = ComponentFactory.get(componentName);
-    const result = await component.verify(request.pathParams.id, request.body.proofObject);
+    const result = await component.verify(request.pathParams.id);
     return {
         headers: {
             [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
@@ -329,39 +388,50 @@ class ImmutableProofService {
      */
     _immutableStorage;
     /**
-     * The assertion method id to use for the proofs.
+     * The background task connector.
+     * @internal
+     */
+    _backgroundTaskConnector;
+    /**
+     * The event bus component.
      * @internal
      */
-    _assertionMethodId;
+    _eventBusComponent;
     /**
-     * The proof config key id to use for the proofs.
+     * The verification method id to use for the proofs.
      * @internal
      */
-    _proofConfigKeyId;
+    _verificationMethodId;
     /**
-     * Are we currently processing proofs.
+     * The proof hash key id to use for the proofs.
      * @internal
      */
-    _processing;
+    _proofHashKeyId;
+    /**
+     * The identity connector type.
+     * @internal
+     */
+    _identityConnectorType;
     /**
      * Create a new instance of ImmutableProofService.
      * @param options The dependencies for the immutable proof connector.
-     * @param options.config The configuration for the connector.
-     * @param options.vaultConnectorType The vault connector type, defaults to "vault".
-     * @param options.immutableProofEntityStorageType The entity storage for proofs, defaults to "immutable-proof".
-     * @param options.immutableStorageType The immutable storage, defaults to "immutable-proof".
-     * @param options.identityConnectorType The identity connector type, defaults to "identity".
      */
     constructor(options) {
         this._vaultConnector = VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
         this._proofStorage = EntityStorageConnectorFactory.get(options?.immutableProofEntityStorageType ?? StringHelper.kebabCase("ImmutableProof"));
-        this._immutableStorage = ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-proof");
-        this._identityConnector = IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        this._immutableStorage = ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-storage");
+        this._identityConnectorType = options?.identityConnectorType ?? "identity";
+        this._identityConnector = IdentityConnectorFactory.get(this._identityConnectorType);
+        this._backgroundTaskConnector = BackgroundTaskConnectorFactory.get(options?.backgroundTaskConnectorType ?? "background-task");
+        if (Is.stringValue(options?.eventBusComponentType)) {
+            this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType);
+        }
         this._config = options?.config ?? {};
-        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
-        this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
-        SchemaOrgDataTypes.registerRedirects();
-        this._processing = false;
+        this._verificationMethodId = this._config.verificationMethodId ?? "immutable-proof-assertion";
+        this._proofHashKeyId = this._config.proofHashKeyId ?? "immutable-proof-hash";
+        this._backgroundTaskConnector.registerHandler("immutable-proof", "@twin.org/immutable-proof-task", "processProofTask", async (task) => {
+            await this.finaliseTask(task);
+        });
     }
     /**
      * Create a new authentication proof.
@@ -391,7 +461,16 @@ class ImmutableProofService {
                 proofObjectHash: Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs();
+            const immutableProof = this.proofEntityToJsonLd(proofEntity);
+            const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+            const proofTaskPayload = {
+                proofId: id,
+                nodeIdentity,
+                identityConnectorType: this._identityConnectorType,
+                assertionMethodId: this._verificationMethodId,
+                hashData: Converter.bytesToHex(hashData)
+            };
+            await this._backgroundTaskConnector.create("immutable-proof", proofTaskPayload);
             return new Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -414,7 +493,7 @@ class ImmutableProofService {
             });
         }
         try {
-            const { immutableProof } = await this.internalGet(id);
+            const { immutableProof } = await this.internalGet(id, false);
             const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
             return compacted;
         }
@@ -425,11 +504,10 @@ class ImmutableProofService {
     /**
      * Verify an authentication proof.
      * @param id The id of the proof to verify.
-     * @param proofObject The object to verify as JSON-LD.
      * @returns The result of the verification and any failures.
      * @throws NotFoundError if the proof is not found.
      */
-    async verify(id, proofObject) {
+    async verify(id) {
         Guards.stringValue(this.CLASS_NAME, "id", id);
         const urnParsed = Urn.fromValidString(id);
         if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
@@ -439,7 +517,7 @@ class ImmutableProofService {
             });
         }
         try {
-            const { verified, failure } = await this.internalGet(id, proofObject);
+            const { verified, failure } = await this.internalGet(id, true);
             return {
                 "@context": ImmutableProofTypes.ContextRoot,
                 type: ImmutableProofTypes.ImmutableProofVerification,
@@ -505,13 +583,9 @@ class ImmutableProofService {
      * @returns The model.
      * @internal
      */
-    proofEntityToModel(proofEntity) {
+    proofEntityToJsonLd(proofEntity) {
         const model = {
-            "@context": [
-                ImmutableProofTypes.ContextRoot,
-                SchemaOrgTypes.ContextRoot,
-                DidContexts.ContextVCDataIntegrity
-            ],
+            "@context": ImmutableProofTypes.ContextRoot,
             type: ImmutableProofTypes.ImmutableProof,
             id: proofEntity.id,
             userIdentity: proofEntity.userIdentity,
@@ -521,74 +595,61 @@ class ImmutableProofService {
         return model;
     }
     /**
-     * Start processing proofs.
-     * @returns Nothing.
+     * Process a proof.
+     * @param proofEntity The proof entity to process.
      * @internal
      */
-    startProcessingProofs() {
-        if (!this._processing) {
-            setTimeout(async () => {
-                await this.processProofs();
-            }, 0);
-        }
-    }
-    /**
-     * Process the proofs.
-     * @internal
-     */
-    async processProofs() {
-        // Get the oldest pending proof, plus one more, we can then determine whether to
-        // trigger another process after this one
-        const pendingProofs = await this._proofStorage.query({
-            property: "immutableStorageId",
-            comparison: ComparisonOperator.Equals,
-            value: undefined
-        }, [
-            {
-                property: "dateCreated",
-                sortDirection: SortDirection.Ascending
+    async finaliseTask(task) {
+        if (task.status === TaskStatus.Success && Is.object(task.payload) && Is.object(task.result)) {
+            const proofEntity = await this._proofStorage.get(task.payload.proofId);
+            if (Is.object(proofEntity)) {
+                const immutableProof = this.proofEntityToJsonLd(proofEntity);
+                // As we are adding the proof to the data we update its context
+                immutableProof["@context"] = [
+                    ImmutableProofTypes.ContextRoot,
+                    DidContexts.ContextVCDataIntegrity
+                ];
+                immutableProof.proof = task.result.proof;
+                if (Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
+                const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+                const immutableStoreResult = await this._immutableStorage.store(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
+                proofEntity.immutableStorageId = immutableStoreResult.id;
+                await this._proofStorage.set(proofEntity);
+                await this._eventBusComponent?.publish(ImmutableProofTopics.ProofCreated, { id: new Urn(ImmutableProofService.NAMESPACE, task.payload.proofId).toString() });
             }
-        ], undefined, undefined, 2);
-        if (pendingProofs.entities.length > 0) {
-            const proofEntity = pendingProofs.entities[0];
-            const immutableProof = this.proofEntityToModel(proofEntity);
-            const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
-            immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
-            proofEntity.dateCreated = immutableProof.proof.created ?? new Date(Date.now()).toISOString();
-            const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-            proofEntity.immutableStorageId = await this._immutableStorage.store(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
-            await this._proofStorage.set(proofEntity);
-        }
-        // If there are still remaining proofs, start the timer again
-        this._processing = false;
-        if (pendingProofs.entities.length > 1) {
-            this.startProcessingProofs();
         }
     }
     /**
      * Verify an authentication proof.
      * @param id The id of the proof to verify.
-     * @param proofObject The object to verify as JSON-LD.
+     * @param verify Validate the proof.
      * @returns The result of the verification and any failures.
      * @throws NotFoundError if the proof is not found.
      * @internal
      */
-    async internalGet(id, proofObject) {
+    async internalGet(id, verify) {
         const urnParsed = Urn.fromValidString(id);
         const proofId = urnParsed.namespaceSpecific(0);
         const proofEntity = await this._proofStorage.get(proofId);
         if (Is.empty(proofEntity)) {
             throw new NotFoundError(this.CLASS_NAME, "proofNotFound", id);
         }
-        let proofModel = await this.proofEntityToModel(proofEntity);
+        let proofModel = await this.proofEntityToJsonLd(proofEntity);
         let verified = false;
         let failure = ImmutableProofFailure.NotIssued;
         if (Is.stringValue(proofEntity.immutableStorageId)) {
             failure = ImmutableProofFailure.ProofMissing;
-            const immutableData = await this._immutableStorage.get(proofEntity.immutableStorageId);
-            if (Is.uint8Array(immutableData)) {
-                proofModel = ObjectHelper.fromBytes(immutableData);
-                if (Is.object(proofModel.proof) && Is.object(proofObject)) {
+            const immutableResult = await this._immutableStorage.get(proofEntity.immutableStorageId);
+            if (Is.uint8Array(immutableResult.data)) {
+                proofModel = ObjectHelper.fromBytes(immutableResult.data);
+                proofModel.immutableReceipt = immutableResult.receipt;
+                // As we are adding the receipt to the data we update its context
+                if (Is.array(proofModel["@context"])) {
+                    proofModel["@context"].push(ImmutableStorageTypes.ContextRoot);
+                }
+                if (verify && Is.object(proofModel.proof)) {
                     if (proofModel.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
                         failure = ImmutableProofFailure.CryptoSuiteMismatch;
                     }
@@ -624,84 +685,21 @@ class ImmutableProofService {
      * @internal
      */
     async generateHashData(nodeIdentity, immutableProof) {
-        const canonicalDocument = JsonHelper.canonicalize(ObjectHelper.omit(immutableProof, ["proof"]));
-        const proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
-        const proofConfigHash = Sha256.sum256(proofConfigKey.privateKey);
+        // We hash the data for the proof without the the proof or immutable receipt for the proof
+        // without these objects we can simplify the context
+        const object = ObjectHelper.omit(immutableProof, ["proof", "immutableReceipt"]);
+        object["@context"] = ImmutableProofTypes.ContextRoot;
+        const canonicalDocument = JsonHelper.canonicalize(object);
+        const proofKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofHashKeyId}`);
+        const proofHash = Sha256.sum256(proofKey.privateKey);
         const transformedDocumentHash = Sha256.sum256(Converter.utf8ToBytes(canonicalDocument));
-        const hashData = new Uint8Array(proofConfigHash.length + transformedDocumentHash.length);
-        hashData.set(proofConfigHash);
-        hashData.set(transformedDocumentHash, proofConfigHash.length);
+        const hashData = new Uint8Array(proofHash.length + transformedDocumentHash.length);
+        hashData.set(proofHash);
+        hashData.set(transformedDocumentHash, proofHash.length);
         return hashData;
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the immutable proof.
- */
-let ImmutableProof = class ImmutableProof {
-    /**
-     * The id of the proof.
-     */
-    id;
-    /**
-     * The identity of the node which controls the proof.
-     */
-    nodeIdentity;
-    /**
-     * The identity of the user which created the proof.
-     */
-    userIdentity;
-    /**
-     * The date/time of when the proof was created.
-     */
-    dateCreated;
-    /**
-     * The associated id for the item.
-     */
-    proofObjectId;
-    /**
-     * The associated hash for the item.
-     */
-    proofObjectHash;
-    /**
-     * The immutable storage id.
-     */
-    immutableStorageId;
-};
-__decorate([
-    property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "id", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "nodeIdentity", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "userIdentity", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "proofObjectId", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "proofObjectHash", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "immutableStorageId", void 0);
-ImmutableProof = __decorate([
-    entity()
-], ImmutableProof);
-
 const restEntryPoints = [
     {
         name: "immutable-proof",

package/dist/types/immutableProofService.d.ts

@@ -1,6 +1,6 @@
 import { type IJsonLdNodeObject } from "@twin.org/data-json-ld";
-import { type IImmutableProofVerification, type IImmutableProof, type IImmutableProofComponent } from "@twin.org/immutable-proof-models";
-import type { IImmutableProofServiceConfig } from "./models/IImmutableProofServiceConfig";
+import { type IImmutableProof, type IImmutableProofComponent, type IImmutableProofVerification } from "@twin.org/immutable-proof-models";
+import type { IImmutableProofServiceConstructorOptions } from "./models/IImmutableProofServiceConstructorOptions";
 /**
  * Class for performing immutable proof operations.
  */
@@ -16,19 +16,8 @@ export declare class ImmutableProofService implements IImmutableProofComponent {
     /**
      * Create a new instance of ImmutableProofService.
      * @param options The dependencies for the immutable proof connector.
-     * @param options.config The configuration for the connector.
-     * @param options.vaultConnectorType The vault connector type, defaults to "vault".
-     * @param options.immutableProofEntityStorageType The entity storage for proofs, defaults to "immutable-proof".
-     * @param options.immutableStorageType The immutable storage, defaults to "immutable-proof".
-     * @param options.identityConnectorType The identity connector type, defaults to "identity".
      */
-    constructor(options?: {
-        vaultConnectorType?: string;
-        immutableProofEntityStorageType?: string;
-        immutableStorageType?: string;
-        config?: IImmutableProofServiceConfig;
-        identityConnectorType?: string;
-    });
+    constructor(options?: IImmutableProofServiceConstructorOptions);
     /**
      * Create a new authentication proof.
      * @param proofObject The object for the proof as JSON-LD.
@@ -47,11 +36,10 @@ export declare class ImmutableProofService implements IImmutableProofComponent {
     /**
      * Verify an authentication proof.
      * @param id The id of the proof to verify.
-     * @param proofObject The object to verify as JSON-LD.
      * @returns The result of the verification and any failures.
      * @throws NotFoundError if the proof is not found.
      */
-    verify(id: string, proofObject: IJsonLdNodeObject): Promise<IImmutableProofVerification>;
+    verify(id: string): Promise<IImmutableProofVerification>;
     /**
      * Remove the immutable storage for the proof.
      * @param id The id of the proof to remove the storage from.

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
+export * from "./entities/immutableProof";
 export * from "./immutableProofRoutes";
 export * from "./immutableProofService";
-export * from "./entities/immutableProof";
 export * from "./models/IImmutableProofServiceConfig";
+export * from "./models/IImmutableProofServiceConstructorOptions";
 export * from "./restEntryPoints";
 export * from "./schema";

package/dist/types/models/IImmutableProofServiceConfig.d.ts

@@ -3,13 +3,13 @@
  */
 export interface IImmutableProofServiceConfig {
     /**
-     * The assertion method id to use for the stream.
-     * @default immutable-proof
+     * The verification method id to use for the proof.
+     * @default immutable-proof-assertion
      */
-    assertionMethodId?: string;
+    verificationMethodId?: string;
     /**
-     * The key to use in the proof config.
-     * @default immutable-proof
+     * The key to use in the proof hash.
+     * @default immutable-proof-hash
      */
-    proofConfigKeyId?: string;
+    proofHashKeyId?: string;
 }

package/dist/types/models/IImmutableProofServiceConstructorOptions.d.ts

@@ -0,0 +1,39 @@
+import type { IImmutableProofServiceConfig } from "./IImmutableProofServiceConfig";
+/**
+ * Options for the immutable proof service constructor.
+ */
+export interface IImmutableProofServiceConstructorOptions {
+    /**
+     * The vault connector type.
+     * @default vault
+     */
+    vaultConnectorType?: string;
+    /**
+     * The entity storage for proofs.
+     * @default immutable-proof
+     */
+    immutableProofEntityStorageType?: string;
+    /**
+     * The immutable storage.
+     * @default immutable-storage
+     */
+    immutableStorageType?: string;
+    /**
+     * The identity connector type.
+     * @default identity
+     */
+    identityConnectorType?: string;
+    /**
+     * The background task connector type.
+     * @default background-task
+     */
+    backgroundTaskConnectorType?: string;
+    /**
+     * The event bus component type, defaults to no event bus.
+     */
+    eventBusComponentType?: string;
+    /**
+     * The configuration for the connector.
+     */
+    config?: IImmutableProofServiceConfig;
+}

package/docs/changelog.md

@@ -1,5 +1,5 @@
 # @twin.org/immutable-proof-service - Changelog
 
-## v0.0.1-next.2
+## v0.0.1-next.20
 
 - Initial Release