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

package/dist/esm/index.mjs

@@ -0,0 +1,713 @@
+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 { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
+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 { VaultConnectorFactory } from '@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: HttpStatusCode.created,
+                            headers: {
+                                [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: {
+                            [HeaderTypes.Accept]: MimeTypes.Json
+                        },
+                        pathParams: {
+                            id: "ais:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IImmutableProofGetResponse",
+                examples: [
+                    {
+                        id: "immutableProofGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": ImmutableProofTypes.ContextRoot,
+                                type: ImmutableProofTypes.ImmutableProof,
+                                id: "ais:1234567890",
+                                userIdentity: "user-1",
+                                proofObjectId: "test:1234567890",
+                                proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
+                                proof: {
+                                    "@context": DidContexts.ContextVCDataIntegrity,
+                                    type: DidTypes.DataIntegrityProof,
+                                    cryptosuite: DidCryptoSuites.EdDSAJcs2022,
+                                    created: "2024-08-22T11:56:56.272Z",
+                                    proofPurpose: "assertionMethod",
+                                    proofValue: "7DdiPPYtxLjCD3wA1po2rv..."
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IImmutableProofGetResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "immutableProofJsonLdGetResponseExample",
+                        response: {
+                            headers: {
+                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": ImmutableProofTypes.ContextRoot,
+                                type: ImmutableProofTypes.ImmutableProof,
+                                id: "ais:1234567890",
+                                userIdentity: "user-1",
+                                proofObjectId: "test:1234567890",
+                                proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
+                                proof: {
+                                    "@context": DidContexts.ContextVCDataIntegrity,
+                                    type: DidTypes.DataIntegrityProof,
+                                    cryptosuite: 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: 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) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
+    const component = ComponentFactory.get(componentName);
+    const result = await component.create(request.body.proofObject);
+    return {
+        statusCode: HttpStatusCode.created,
+        headers: {
+            [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) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = ComponentFactory.get(componentName);
+    const result = await component.get(request.pathParams.id);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : 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) {
+    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 component = 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 = 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._config = options?.config ?? {};
+        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
+        this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
+        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) {
+        Guards.object(this.CLASS_NAME, "proofObject", proofObject);
+        Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        try {
+            const validationFailures = [];
+            await JsonLdHelper.validate(proofObject, validationFailures);
+            Validation.asValidationError(this.CLASS_NAME, "proofObject", validationFailures);
+            const id = Converter.bytesToHex(RandomHelper.generate(32), false);
+            const dateCreated = new Date(Date.now()).toISOString();
+            const proofObjectId = ObjectHelper.extractProperty(proofObject, ["@id", "id"], false);
+            const hash = this.calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject);
+            const proofEntity = {
+                id,
+                nodeIdentity,
+                userIdentity,
+                dateCreated,
+                proofObjectId,
+                proofObjectHash: Converter.bytesToBase64(hash)
+            };
+            await this._proofStorage.set(proofEntity);
+            this.startProcessingProofs();
+            return new Urn(ImmutableProofService.NAMESPACE, id).toString();
+        }
+        catch (error) {
+            throw new 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) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        const urnParsed = Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+            throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: ImmutableProofService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const { immutableProof } = await this.internalGet(id);
+            const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+            return compacted;
+        }
+        catch (error) {
+            throw new 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) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        const urnParsed = Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+            throw new 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 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) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        const urnParsed = Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+            throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: ImmutableProofService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const streamId = urnParsed.namespaceSpecific(0);
+            const streamEntity = await this._proofStorage.get(streamId);
+            if (Is.empty(streamEntity)) {
+                throw new NotFoundError(this.CLASS_NAME, "proofNotFound", id);
+            }
+            if (Is.stringValue(streamEntity.immutableStorageId)) {
+                await this._immutableStorage.remove(nodeIdentity, streamEntity.immutableStorageId);
+                delete streamEntity.immutableStorageId;
+                await this._proofStorage.set(streamEntity);
+            }
+        }
+        catch (error) {
+            throw new 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 Blake2b(Blake2b.SIZE_256);
+        b2b.update(Converter.utf8ToBytes(id));
+        b2b.update(Converter.utf8ToBytes(dateCreated));
+        b2b.update(Converter.utf8ToBytes(nodeIdentity));
+        b2b.update(Converter.utf8ToBytes(userIdentity));
+        b2b.update(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": [
+                ImmutableProofTypes.ContextRoot,
+                SchemaOrgTypes.ContextRoot,
+                DidContexts.ContextVCDataIntegrity
+            ],
+            type: 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: ComparisonOperator.Equals,
+            value: undefined
+        }, [
+            {
+                property: "dateCreated",
+                sortDirection: 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 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.
+     * @returns The result of the verification and any failures.
+     * @throws NotFoundError if the proof is not found.
+     * @internal
+     */
+    async internalGet(id, proofObject) {
+        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 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)) {
+                    if (proofModel.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
+                        failure = ImmutableProofFailure.CryptoSuiteMismatch;
+                    }
+                    else if (proofModel.proof.type !== DidTypes.DataIntegrityProof) {
+                        failure = 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 = 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 = JsonHelper.canonicalize(ObjectHelper.omit(immutableProof, ["proof"]));
+        const proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
+        const proofConfigHash = Sha256.sum256(proofConfigKey.privateKey);
+        const transformedDocumentHash = Sha256.sum256(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.
+ */
+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",
+        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() {
+    EntitySchemaFactory.register("ImmutableProof", () => EntitySchemaHelper.getSchema(ImmutableProof));
+}
+
+export { ImmutableProof, ImmutableProofService, generateRestRoutesImmutableProof, immutableProofCreate, immutableProofGet, immutableProofVerify, initSchema, restEntryPoints, tagsImmutableProof };