@twin.org/immutable-proof-service 0.0.1-next.1

package/dist/cjs/index.cjs

@@ -0,0 +1,722 @@
+'use strict';
+
+var core = require('@twin.org/core');
+var immutableProofModels = require('@twin.org/immutable-proof-models');
+var standardsW3cDid = require('@twin.org/standards-w3c-did');
+var web = require('@twin.org/web');
+var crypto = require('@twin.org/crypto');
+var dataJsonLd = require('@twin.org/data-json-ld');
+var dataSchemaOrg = require('@twin.org/data-schema-org');
+var entity = require('@twin.org/entity');
+var entityStorageModels = require('@twin.org/entity-storage-models');
+var identityModels = require('@twin.org/identity-models');
+var immutableStorageModels = require('@twin.org/immutable-storage-models');
+var vaultModels = require('@twin.org/vault-models');
+
+/**
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE = "immutableProofRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+const tagsImmutableProof = [
+    {
+        name: "Immutable Proof",
+        description: "Endpoints which are modelled to access an immutable proof contract."
+    }
+];
+/**
+ * The REST routes for immutable proof.
+ * @param baseRouteName Prefix to prepend to the paths.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @returns The generated routes.
+ */
+function generateRestRoutesImmutableProof(baseRouteName, componentName) {
+    const createRoute = {
+        operationId: "immutableProofCreate",
+        summary: "Create a proof",
+        tag: tagsImmutableProof[0].name,
+        method: "POST",
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => immutableProofCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IImmutableProofCreateRequest",
+            examples: [
+                {
+                    id: "immutableProofCreateRequestExample",
+                    request: {
+                        body: {
+                            proofObject: {
+                                "@context": "http://schema.org",
+                                type: "Person",
+                                name: "John Smith"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse",
+                examples: [
+                    {
+                        id: "immutableProofCreateResponseExample",
+                        response: {
+                            statusCode: web.HttpStatusCode.created,
+                            headers: {
+                                [web.HeaderTypes.Location]: "test:1234567890"
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const getRoute = {
+        operationId: "immutableProofGet",
+        summary: "Get a proof",
+        tag: tagsImmutableProof[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:id`,
+        handler: async (httpRequestContext, request) => immutableProofGet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IImmutableProofGetRequest",
+            examples: [
+                {
+                    id: "immutableProofGetRequestExample",
+                    request: {
+                        headers: {
+                            [web.HeaderTypes.Accept]: web.MimeTypes.Json
+                        },
+                        pathParams: {
+                            id: "ais:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IImmutableProofGetResponse",
+                examples: [
+                    {
+                        id: "immutableProofGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
+                                id: "ais:1234567890",
+                                userIdentity: "user-1",
+                                proofObjectId: "test:1234567890",
+                                proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
+                                proof: {
+                                    "@context": standardsW3cDid.DidContexts.ContextVCDataIntegrity,
+                                    type: standardsW3cDid.DidTypes.DataIntegrityProof,
+                                    cryptosuite: standardsW3cDid.DidCryptoSuites.EdDSAJcs2022,
+                                    created: "2024-08-22T11:56:56.272Z",
+                                    proofPurpose: "assertionMethod",
+                                    proofValue: "7DdiPPYtxLjCD3wA1po2rv..."
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IImmutableProofGetResponse",
+                mimeType: web.MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "immutableProofJsonLdGetResponseExample",
+                        response: {
+                            headers: {
+                                [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
+                                id: "ais:1234567890",
+                                userIdentity: "user-1",
+                                proofObjectId: "test:1234567890",
+                                proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
+                                proof: {
+                                    "@context": standardsW3cDid.DidContexts.ContextVCDataIntegrity,
+                                    type: standardsW3cDid.DidTypes.DataIntegrityProof,
+                                    cryptosuite: standardsW3cDid.DidCryptoSuites.EdDSAJcs2022,
+                                    created: "2024-08-22T11:56:56.272Z",
+                                    proofPurpose: "assertionMethod",
+                                    proofValue: "7DdiPPYtxLjCD3wA1po2rv..."
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const verifyRoute = {
+        operationId: "immutableProofVerify",
+        summary: "Verify a proof",
+        tag: tagsImmutableProof[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:id`,
+        handler: async (httpRequestContext, request) => immutableProofVerify(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IImmutableProofVerifyRequest",
+            examples: [
+                {
+                    id: "immutableProofVerifyRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890"
+                        },
+                        body: {
+                            proofObject: {
+                                "@context": "http://schema.org",
+                                type: "Person",
+                                name: "John Smith"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IImmutableProofVerifyResponse",
+                examples: [
+                    {
+                        id: "immutableProofVerifyResponseExample",
+                        response: {
+                            body: {
+                                verified: true
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IImmutableProofVerifyResponse",
+                examples: [
+                    {
+                        id: "immutableProofVerifyResponseFailExample",
+                        response: {
+                            body: {
+                                verified: false,
+                                failure: immutableProofModels.ImmutableProofFailure.ProofTypeMismatch
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    return [createRoute, getRoute, verifyRoute];
+}
+/**
+ * Create a proof.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function immutableProofCreate(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.create(request.body.proofObject);
+    return {
+        statusCode: web.HttpStatusCode.created,
+        headers: {
+            [web.HeaderTypes.Location]: result
+        }
+    };
+}
+/**
+ * Get the proof.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function immutableProofGet(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.get(request.pathParams.id);
+    return {
+        headers: {
+            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
+/**
+ * Verify the proof.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function immutableProofVerify(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    core.Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.verify(request.pathParams.id, request.body.proofObject);
+    return {
+        body: result
+    };
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class for performing immutable proof operations.
+ */
+class ImmutableProofService {
+    /**
+     * The namespace for the service.
+     */
+    static NAMESPACE = "immutable-proof";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "ImmutableProofService";
+    /**
+     * The configuration for the connector.
+     * @internal
+     */
+    _config;
+    /**
+     * The vault connector.
+     * @internal
+     */
+    _vaultConnector;
+    /**
+     * The identity connector.
+     * @internal
+     */
+    _identityConnector;
+    /**
+     * The entity storage for proofs.
+     * @internal
+     */
+    _proofStorage;
+    /**
+     * The immutable storage for the credentials.
+     * @internal
+     */
+    _immutableStorage;
+    /**
+     * The assertion method id to use for the proofs.
+     * @internal
+     */
+    _assertionMethodId;
+    /**
+     * The proof config key id to use for the proofs.
+     * @internal
+     */
+    _proofConfigKeyId;
+    /**
+     * Are we currently processing proofs.
+     * @internal
+     */
+    _processing;
+    /**
+     * 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 = vaultModels.VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
+        this._proofStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.immutableProofEntityStorageType ?? core.StringHelper.kebabCase("ImmutableProof"));
+        this._immutableStorage = immutableStorageModels.ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-proof");
+        this._identityConnector = identityModels.IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        this._config = options?.config ?? {};
+        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
+        this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
+        dataSchemaOrg.SchemaOrgDataTypes.registerRedirects();
+        this._processing = false;
+    }
+    /**
+     * Create a new authentication proof.
+     * @param proofObject The object for the proof as JSON-LD.
+     * @param userIdentity The identity to create the immutable proof operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The id of the new authentication proof.
+     */
+    async create(proofObject, userIdentity, nodeIdentity) {
+        core.Guards.object(this.CLASS_NAME, "proofObject", proofObject);
+        core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        try {
+            const validationFailures = [];
+            await dataJsonLd.JsonLdHelper.validate(proofObject, validationFailures);
+            core.Validation.asValidationError(this.CLASS_NAME, "proofObject", validationFailures);
+            const id = core.Converter.bytesToHex(core.RandomHelper.generate(32), false);
+            const dateCreated = new Date(Date.now()).toISOString();
+            const proofObjectId = core.ObjectHelper.extractProperty(proofObject, ["@id", "id"], false);
+            const hash = this.calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject);
+            const proofEntity = {
+                id,
+                nodeIdentity,
+                userIdentity,
+                dateCreated,
+                proofObjectId,
+                proofObjectHash: core.Converter.bytesToBase64(hash)
+            };
+            await this._proofStorage.set(proofEntity);
+            this.startProcessingProofs();
+            return new core.Urn(ImmutableProofService.NAMESPACE, id).toString();
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "createFailed", undefined, error);
+        }
+    }
+    /**
+     * Get an authentication proof.
+     * @param id The id of the proof to get.
+     * @returns The proof.
+     * @throws NotFoundError if the proof is not found.
+     */
+    async get(id) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: ImmutableProofService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const { immutableProof } = await this.internalGet(id);
+            const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+            return compacted;
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
+        }
+    }
+    /**
+     * 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) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: ImmutableProofService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const { verified, failure } = await this.internalGet(id, proofObject);
+            return {
+                verified,
+                failure
+            };
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "verifyFailed", undefined, error);
+        }
+    }
+    /**
+     * Remove the immutable storage for the proof.
+     * @param id The id of the proof to remove the storage from.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns Nothing.
+     * @throws NotFoundError if the proof is not found.
+     */
+    async removeImmutable(id, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: ImmutableProofService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const streamId = urnParsed.namespaceSpecific(0);
+            const streamEntity = await this._proofStorage.get(streamId);
+            if (core.Is.empty(streamEntity)) {
+                throw new core.NotFoundError(this.CLASS_NAME, "proofNotFound", id);
+            }
+            if (core.Is.stringValue(streamEntity.immutableStorageId)) {
+                await this._immutableStorage.remove(nodeIdentity, streamEntity.immutableStorageId);
+                delete streamEntity.immutableStorageId;
+                await this._proofStorage.set(streamEntity);
+            }
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "removeImmutableFailed", undefined, error);
+        }
+    }
+    /**
+     * Calculate the object hash.
+     * @param object The entry to calculate the hash for.
+     * @returns The hash.
+     * @internal
+     */
+    calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject) {
+        const b2b = new crypto.Blake2b(crypto.Blake2b.SIZE_256);
+        b2b.update(core.Converter.utf8ToBytes(id));
+        b2b.update(core.Converter.utf8ToBytes(dateCreated));
+        b2b.update(core.Converter.utf8ToBytes(nodeIdentity));
+        b2b.update(core.Converter.utf8ToBytes(userIdentity));
+        b2b.update(core.ObjectHelper.toBytes(proofObject));
+        return b2b.digest();
+    }
+    /**
+     * Map the stream entity to a model.
+     * @param proofEntity The stream entity.
+     * @returns The model.
+     * @internal
+     */
+    proofEntityToModel(proofEntity) {
+        const model = {
+            "@context": [
+                immutableProofModels.ImmutableProofTypes.ContextRoot,
+                dataSchemaOrg.SchemaOrgTypes.ContextRoot,
+                standardsW3cDid.DidContexts.ContextVCDataIntegrity
+            ],
+            type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
+            id: proofEntity.id,
+            userIdentity: proofEntity.userIdentity,
+            proofObjectId: proofEntity.proofObjectId,
+            proofObjectHash: proofEntity.proofObjectHash
+        };
+        return model;
+    }
+    /**
+     * Start processing proofs.
+     * @returns Nothing.
+     * @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: entity.ComparisonOperator.Equals,
+            value: undefined
+        }, [
+            {
+                property: "dateCreated",
+                sortDirection: entity.SortDirection.Ascending
+            }
+        ], 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 dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+            proofEntity.immutableStorageId = await this._immutableStorage.store(proofEntity.nodeIdentity, core.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.
+     * @returns The result of the verification and any failures.
+     * @throws NotFoundError if the proof is not found.
+     * @internal
+     */
+    async internalGet(id, proofObject) {
+        const urnParsed = core.Urn.fromValidString(id);
+        const proofId = urnParsed.namespaceSpecific(0);
+        const proofEntity = await this._proofStorage.get(proofId);
+        if (core.Is.empty(proofEntity)) {
+            throw new core.NotFoundError(this.CLASS_NAME, "proofNotFound", id);
+        }
+        let proofModel = await this.proofEntityToModel(proofEntity);
+        let verified = false;
+        let failure = immutableProofModels.ImmutableProofFailure.NotIssued;
+        if (core.Is.stringValue(proofEntity.immutableStorageId)) {
+            failure = immutableProofModels.ImmutableProofFailure.ProofMissing;
+            const immutableData = await this._immutableStorage.get(proofEntity.immutableStorageId);
+            if (core.Is.uint8Array(immutableData)) {
+                proofModel = core.ObjectHelper.fromBytes(immutableData);
+                if (core.Is.object(proofModel.proof) && core.Is.object(proofObject)) {
+                    if (proofModel.proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
+                        failure = immutableProofModels.ImmutableProofFailure.CryptoSuiteMismatch;
+                    }
+                    else if (proofModel.proof.type !== standardsW3cDid.DidTypes.DataIntegrityProof) {
+                        failure = immutableProofModels.ImmutableProofFailure.ProofTypeMismatch;
+                    }
+                    else {
+                        const hashData = await this.generateHashData(proofEntity.nodeIdentity, proofModel);
+                        const isVerified = await this._identityConnector.verifyProof(hashData, proofModel.proof);
+                        if (isVerified) {
+                            verified = true;
+                            failure = undefined;
+                        }
+                        else {
+                            failure = immutableProofModels.ImmutableProofFailure.SignatureMismatch;
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            immutableProof: proofModel,
+            verified,
+            failure
+        };
+    }
+    /**
+     * Generate the hash data for the proof.
+     * Conforms to https://www.w3.org/TR/vc-di-eddsa/#create-proof-eddsa-jcs-2022
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @param immutableProof The immutable proof to generate the hash data for.
+     * @returns The hash data.
+     * @internal
+     */
+    async generateHashData(nodeIdentity, immutableProof) {
+        const canonicalDocument = core.JsonHelper.canonicalize(core.ObjectHelper.omit(immutableProof, ["proof"]));
+        const proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
+        const proofConfigHash = crypto.Sha256.sum256(proofConfigKey.privateKey);
+        const transformedDocumentHash = crypto.Sha256.sum256(core.Converter.utf8ToBytes(canonicalDocument));
+        const hashData = new Uint8Array(proofConfigHash.length + transformedDocumentHash.length);
+        hashData.set(proofConfigHash);
+        hashData.set(transformedDocumentHash, proofConfigHash.length);
+        return hashData;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the immutable proof.
+ */
+exports.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([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "nodeIdentity", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "userIdentity", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "proofObjectId", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "proofObjectHash", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "immutableStorageId", void 0);
+exports.ImmutableProof = __decorate([
+    entity.entity()
+], exports.ImmutableProof);
+
+const restEntryPoints = [
+    {
+        name: "immutable-proof",
+        defaultBaseRoute: "immutable-proof",
+        tags: tagsImmutableProof,
+        generateRoutes: generateRestRoutesImmutableProof
+    }
+];
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialize the schema for the immutable proof entity storage connector.
+ */
+function initSchema() {
+    entity.EntitySchemaFactory.register("ImmutableProof", () => entity.EntitySchemaHelper.getSchema(exports.ImmutableProof));
+}
+
+exports.ImmutableProofService = ImmutableProofService;
+exports.generateRestRoutesImmutableProof = generateRestRoutesImmutableProof;
+exports.immutableProofCreate = immutableProofCreate;
+exports.immutableProofGet = immutableProofGet;
+exports.immutableProofVerify = immutableProofVerify;
+exports.initSchema = initSchema;
+exports.restEntryPoints = restEntryPoints;
+exports.tagsImmutableProof = tagsImmutableProof;