@twin.org/identity-models 0.0.1-next.9 → 0.0.1

package/dist/cjs/index.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var core = require('@twin.org/core');
+var standardsW3cDid = require('@twin.org/standards-w3c-did');
+var web = require('@twin.org/web');
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -21,23 +23,10 @@ const IdentityProfileConnectorFactory = core.Factory.createFactory("identity-pro
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * The roles that an identity can have.
+ * Factory for creating identity resolver connectors.
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const IdentityRole = {
-    /**
-     * Node.
-     */
-    Node: "node",
-    /**
-     * Organization.
-     */
-    Organization: "organization",
-    /**
-     * User.
-     */
-    User: "user"
-};
+const IdentityResolverConnectorFactory = core.Factory.createFactory("identity-resolver-connector");
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -45,27 +34,167 @@ const IdentityRole = {
  * Helper methods for documents.
  */
 class DocumentHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "DocumentHelper";
     /**
      * Parse the document id into its parts.
      * @param documentId The full document id.
      * @returns The parsed document id.
      */
-    static parse(documentId) {
+    static parseId(documentId) {
         if (!core.Is.stringValue(documentId)) {
             return {
                 id: "",
-                hash: ""
+                fragment: ""
             };
         }
-        const hashIndex = documentId.indexOf("#");
+        const fragmentIndex = documentId.indexOf("#");
         return {
-            id: hashIndex === -1 ? documentId : documentId.slice(0, hashIndex),
-            hash: hashIndex === -1 ? undefined : documentId.slice(hashIndex + 1)
+            id: fragmentIndex === -1 ? documentId : documentId.slice(0, fragmentIndex),
+            fragment: fragmentIndex === -1 ? undefined : documentId.slice(fragmentIndex + 1)
         };
     }
+    /**
+     * Join the document id parts.
+     * @param documentId The document id.
+     * @param fragment The fragment part for the identifier.
+     * @returns The full id.
+     */
+    static joinId(documentId, fragment) {
+        if (!core.Is.stringValue(documentId)) {
+            return "";
+        }
+        let fullId = documentId;
+        if (core.Is.stringValue(fragment)) {
+            if (fragment.startsWith(documentId)) {
+                fragment = fragment.slice(documentId.length);
+            }
+            if (fragment.startsWith("#")) {
+                fullId += fragment;
+            }
+            else {
+                fullId += `#${fragment}`;
+            }
+        }
+        return fullId;
+    }
+    /**
+     * Get a verification method from a DID document.
+     * @param didDocument The DID Document to get the method from.
+     * @param methodName The name of the method to get the JWK from.
+     * @param methodType The type of the method, defaults to verificationMethod.
+     * @returns The verification method if found.
+     * @throws Error if the method is not found.
+     */
+    static getVerificationMethod(didDocument, methodName, methodType) {
+        const verificationMethod = didDocument[methodType ?? standardsW3cDid.DidVerificationMethodType.VerificationMethod]?.find(vm => core.Is.object(vm) && vm.id === methodName);
+        if (core.Is.object(verificationMethod)) {
+            return verificationMethod;
+        }
+        throw new core.GeneralError(DocumentHelper.CLASS_NAME, "verificationMethodNotFound", {
+            methodName,
+            methodType
+        });
+    }
+    /**
+     * Gets a JWK from a DID document verification method.
+     * @param didDocument The DID Document to get the method from.
+     * @param methodName The name of the method to get the JWK from.
+     * @param methodType The type of the method, defaults to verificationMethod.
+     * @returns The JWK if found.
+     * @throws Error if the method is not found.
+     */
+    static getJwk(didDocument, methodName, methodType) {
+        const verificationMethod = DocumentHelper.getVerificationMethod(didDocument, methodName, methodType);
+        if (core.Is.object(verificationMethod) && core.Is.object(verificationMethod.publicKeyJwk)) {
+            return verificationMethod.publicKeyJwk;
+        }
+        throw new core.GeneralError(DocumentHelper.CLASS_NAME, "verificationMethodJwkNotFound", {
+            methodName,
+            methodType
+        });
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Helper methods for verification.
+ */
+class VerificationHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "VerificationHelper";
+    /**
+     * Verified the JWT.
+     * @param resolver The resolver to use for finding the document.
+     * @param jwt The token to verify.
+     * @returns The decoded payload.
+     */
+    static async verifyJwt(resolver, jwt) {
+        core.Guards.object(VerificationHelper.CLASS_NAME, "resolver", resolver);
+        core.Guards.string(VerificationHelper.CLASS_NAME, "jwt", jwt);
+        const jwtDecoded = await web.Jwt.decode(jwt);
+        const jwtHeader = jwtDecoded.header;
+        const jwtPayload = jwtDecoded.payload;
+        const jwtSignature = jwtDecoded.signature;
+        if (!core.Is.object(jwtHeader) || !core.Is.object(jwtPayload) || !core.Is.uint8Array(jwtSignature)) {
+            throw new core.GeneralError(VerificationHelper.CLASS_NAME, "jwtDecodeFailed");
+        }
+        const iss = jwtHeader?.iss;
+        const kid = jwtHeader?.kid;
+        core.Guards.stringValue(VerificationHelper.CLASS_NAME, "iss", iss);
+        core.Guards.stringValue(VerificationHelper.CLASS_NAME, "kid", kid);
+        const didDocument = await resolver.identityResolve(iss);
+        const jwk = DocumentHelper.getJwk(didDocument, kid);
+        const publicKey = await web.Jwk.toCryptoKey(jwk);
+        return web.Jwt.verify(jwt, publicKey);
+    }
+    /**
+     * Verified the proof for the document e.g. verifiable credential.
+     * @param resolver The resolver to use for finding the document.
+     * @param secureDocument The secure document to verify.
+     * @returns True if the verification is successful.
+     */
+    static async verifyProof(resolver, secureDocument) {
+        core.Guards.object(VerificationHelper.CLASS_NAME, "resolver", resolver);
+        core.Guards.object(VerificationHelper.CLASS_NAME, "secureDocument", secureDocument);
+        core.Guards.object(VerificationHelper.CLASS_NAME, "secureDocument.proof", secureDocument.proof);
+        const proofList = core.Is.array(secureDocument.proof)
+            ? secureDocument.proof
+            : [secureDocument.proof];
+        const documentCache = {};
+        for (const proof of proofList) {
+            if (!core.Is.stringValue(proof?.verificationMethod)) {
+                throw new core.GeneralError(VerificationHelper.CLASS_NAME, "proofMissingVerificationMethod");
+            }
+            const proofVerificationMethod = DocumentHelper.parseId(proof.verificationMethod);
+            if (!core.Is.stringValue(proofVerificationMethod.fragment)) {
+                throw new core.GeneralError(VerificationHelper.CLASS_NAME, "proofMissingVerificationMethod");
+            }
+            let document;
+            if (documentCache[proofVerificationMethod.id]) {
+                document = documentCache[proofVerificationMethod.id];
+            }
+            else {
+                document = await resolver.identityResolve(proofVerificationMethod.id);
+                documentCache[proofVerificationMethod.id] = document;
+            }
+            const verificationJwk = await DocumentHelper.getJwk(document, proofVerificationMethod.id);
+            const verified = standardsW3cDid.ProofHelper.verifyProof(secureDocument, proof, verificationJwk);
+            if (!verified) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 
 exports.DocumentHelper = DocumentHelper;
 exports.IdentityConnectorFactory = IdentityConnectorFactory;
 exports.IdentityProfileConnectorFactory = IdentityProfileConnectorFactory;
-exports.IdentityRole = IdentityRole;
+exports.IdentityResolverConnectorFactory = IdentityResolverConnectorFactory;
+exports.VerificationHelper = VerificationHelper;

package/dist/esm/index.mjs

@@ -1,4 +1,6 @@
-import { Factory, Is } from '@twin.org/core';
+import { Factory, Is, GeneralError, Guards } from '@twin.org/core';
+import { DidVerificationMethodType, ProofHelper } from '@twin.org/standards-w3c-did';
+import { Jwt, Jwk } from '@twin.org/web';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -19,23 +21,10 @@ const IdentityProfileConnectorFactory = Factory.createFactory("identity-profile-
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * The roles that an identity can have.
+ * Factory for creating identity resolver connectors.
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const IdentityRole = {
-    /**
-     * Node.
-     */
-    Node: "node",
-    /**
-     * Organization.
-     */
-    Organization: "organization",
-    /**
-     * User.
-     */
-    User: "user"
-};
+const IdentityResolverConnectorFactory = Factory.createFactory("identity-resolver-connector");
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -43,24 +32,163 @@ const IdentityRole = {
  * Helper methods for documents.
  */
 class DocumentHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "DocumentHelper";
     /**
      * Parse the document id into its parts.
      * @param documentId The full document id.
      * @returns The parsed document id.
      */
-    static parse(documentId) {
+    static parseId(documentId) {
         if (!Is.stringValue(documentId)) {
             return {
                 id: "",
-                hash: ""
+                fragment: ""
             };
         }
-        const hashIndex = documentId.indexOf("#");
+        const fragmentIndex = documentId.indexOf("#");
         return {
-            id: hashIndex === -1 ? documentId : documentId.slice(0, hashIndex),
-            hash: hashIndex === -1 ? undefined : documentId.slice(hashIndex + 1)
+            id: fragmentIndex === -1 ? documentId : documentId.slice(0, fragmentIndex),
+            fragment: fragmentIndex === -1 ? undefined : documentId.slice(fragmentIndex + 1)
         };
     }
+    /**
+     * Join the document id parts.
+     * @param documentId The document id.
+     * @param fragment The fragment part for the identifier.
+     * @returns The full id.
+     */
+    static joinId(documentId, fragment) {
+        if (!Is.stringValue(documentId)) {
+            return "";
+        }
+        let fullId = documentId;
+        if (Is.stringValue(fragment)) {
+            if (fragment.startsWith(documentId)) {
+                fragment = fragment.slice(documentId.length);
+            }
+            if (fragment.startsWith("#")) {
+                fullId += fragment;
+            }
+            else {
+                fullId += `#${fragment}`;
+            }
+        }
+        return fullId;
+    }
+    /**
+     * Get a verification method from a DID document.
+     * @param didDocument The DID Document to get the method from.
+     * @param methodName The name of the method to get the JWK from.
+     * @param methodType The type of the method, defaults to verificationMethod.
+     * @returns The verification method if found.
+     * @throws Error if the method is not found.
+     */
+    static getVerificationMethod(didDocument, methodName, methodType) {
+        const verificationMethod = didDocument[methodType ?? DidVerificationMethodType.VerificationMethod]?.find(vm => Is.object(vm) && vm.id === methodName);
+        if (Is.object(verificationMethod)) {
+            return verificationMethod;
+        }
+        throw new GeneralError(DocumentHelper.CLASS_NAME, "verificationMethodNotFound", {
+            methodName,
+            methodType
+        });
+    }
+    /**
+     * Gets a JWK from a DID document verification method.
+     * @param didDocument The DID Document to get the method from.
+     * @param methodName The name of the method to get the JWK from.
+     * @param methodType The type of the method, defaults to verificationMethod.
+     * @returns The JWK if found.
+     * @throws Error if the method is not found.
+     */
+    static getJwk(didDocument, methodName, methodType) {
+        const verificationMethod = DocumentHelper.getVerificationMethod(didDocument, methodName, methodType);
+        if (Is.object(verificationMethod) && Is.object(verificationMethod.publicKeyJwk)) {
+            return verificationMethod.publicKeyJwk;
+        }
+        throw new GeneralError(DocumentHelper.CLASS_NAME, "verificationMethodJwkNotFound", {
+            methodName,
+            methodType
+        });
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Helper methods for verification.
+ */
+class VerificationHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "VerificationHelper";
+    /**
+     * Verified the JWT.
+     * @param resolver The resolver to use for finding the document.
+     * @param jwt The token to verify.
+     * @returns The decoded payload.
+     */
+    static async verifyJwt(resolver, jwt) {
+        Guards.object(VerificationHelper.CLASS_NAME, "resolver", resolver);
+        Guards.string(VerificationHelper.CLASS_NAME, "jwt", jwt);
+        const jwtDecoded = await Jwt.decode(jwt);
+        const jwtHeader = jwtDecoded.header;
+        const jwtPayload = jwtDecoded.payload;
+        const jwtSignature = jwtDecoded.signature;
+        if (!Is.object(jwtHeader) || !Is.object(jwtPayload) || !Is.uint8Array(jwtSignature)) {
+            throw new GeneralError(VerificationHelper.CLASS_NAME, "jwtDecodeFailed");
+        }
+        const iss = jwtHeader?.iss;
+        const kid = jwtHeader?.kid;
+        Guards.stringValue(VerificationHelper.CLASS_NAME, "iss", iss);
+        Guards.stringValue(VerificationHelper.CLASS_NAME, "kid", kid);
+        const didDocument = await resolver.identityResolve(iss);
+        const jwk = DocumentHelper.getJwk(didDocument, kid);
+        const publicKey = await Jwk.toCryptoKey(jwk);
+        return Jwt.verify(jwt, publicKey);
+    }
+    /**
+     * Verified the proof for the document e.g. verifiable credential.
+     * @param resolver The resolver to use for finding the document.
+     * @param secureDocument The secure document to verify.
+     * @returns True if the verification is successful.
+     */
+    static async verifyProof(resolver, secureDocument) {
+        Guards.object(VerificationHelper.CLASS_NAME, "resolver", resolver);
+        Guards.object(VerificationHelper.CLASS_NAME, "secureDocument", secureDocument);
+        Guards.object(VerificationHelper.CLASS_NAME, "secureDocument.proof", secureDocument.proof);
+        const proofList = Is.array(secureDocument.proof)
+            ? secureDocument.proof
+            : [secureDocument.proof];
+        const documentCache = {};
+        for (const proof of proofList) {
+            if (!Is.stringValue(proof?.verificationMethod)) {
+                throw new GeneralError(VerificationHelper.CLASS_NAME, "proofMissingVerificationMethod");
+            }
+            const proofVerificationMethod = DocumentHelper.parseId(proof.verificationMethod);
+            if (!Is.stringValue(proofVerificationMethod.fragment)) {
+                throw new GeneralError(VerificationHelper.CLASS_NAME, "proofMissingVerificationMethod");
+            }
+            let document;
+            if (documentCache[proofVerificationMethod.id]) {
+                document = documentCache[proofVerificationMethod.id];
+            }
+            else {
+                document = await resolver.identityResolve(proofVerificationMethod.id);
+                documentCache[proofVerificationMethod.id] = document;
+            }
+            const verificationJwk = await DocumentHelper.getJwk(document, proofVerificationMethod.id);
+            const verified = ProofHelper.verifyProof(secureDocument, proof, verificationJwk);
+            if (!verified) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 
-export { DocumentHelper, IdentityConnectorFactory, IdentityProfileConnectorFactory, IdentityRole };
+export { DocumentHelper, IdentityConnectorFactory, IdentityProfileConnectorFactory, IdentityResolverConnectorFactory, VerificationHelper };

package/dist/types/factories/identityResolverConnectorFactory.d.ts

@@ -0,0 +1,6 @@
+import { Factory } from "@twin.org/core";
+import type { IIdentityResolverConnector } from "../models/IIdentityResolverConnector";
+/**
+ * Factory for creating identity resolver connectors.
+ */
+export declare const IdentityResolverConnectorFactory: Factory<IIdentityResolverConnector>;

package/dist/types/index.d.ts

@@ -1,18 +1,44 @@
 export * from "./factories/identityConnectorFactory";
 export * from "./factories/identityProfileConnectorFactory";
-export * from "./models/api/IIdentityProfileCreateRequest";
-export * from "./models/api/IIdentityProfileGetPublicRequest";
-export * from "./models/api/IIdentityProfileGetPublicResponse";
-export * from "./models/api/IIdentityProfileGetRequest";
-export * from "./models/api/IIdentityProfileGetResponse";
-export * from "./models/api/IIdentityProfileListRequest";
-export * from "./models/api/IIdentityProfileListResponse";
-export * from "./models/api/IIdentityProfileUpdateRequest";
-export * from "./models/api/IIdentityResolveRequest";
-export * from "./models/api/IIdentityResolveResponse";
-export * from "./models/identityRole";
+export * from "./factories/identityResolverConnectorFactory";
+export * from "./models/api/identity/IIdentityCreateRequest";
+export * from "./models/api/identity/IIdentityCreateResponse";
+export * from "./models/api/identity/IIdentityProofCreateRequest";
+export * from "./models/api/identity/IIdentityProofCreateResponse";
+export * from "./models/api/identity/IIdentityProofVerifyRequest";
+export * from "./models/api/identity/IIdentityProofVerifyResponse";
+export * from "./models/api/identity/IIdentityRemoveRequest";
+export * from "./models/api/identity/IIdentityServiceCreateRequest";
+export * from "./models/api/identity/IIdentityServiceCreateResponse";
+export * from "./models/api/identity/IIdentityServiceRemoveRequest";
+export * from "./models/api/identity/IIdentityVerifiableCredentialCreateRequest";
+export * from "./models/api/identity/IIdentityVerifiableCredentialCreateResponse";
+export * from "./models/api/identity/IIdentityVerifiableCredentialRevokeRequest";
+export * from "./models/api/identity/IIdentityVerifiableCredentialUnrevokeRequest";
+export * from "./models/api/identity/IIdentityVerifiableCredentialVerifyRequest";
+export * from "./models/api/identity/IIdentityVerifiableCredentialVerifyResponse";
+export * from "./models/api/identity/IIdentityVerifiablePresentationCreateRequest";
+export * from "./models/api/identity/IIdentityVerifiablePresentationCreateResponse";
+export * from "./models/api/identity/IIdentityVerifiablePresentationVerifyRequest";
+export * from "./models/api/identity/IIdentityVerifiablePresentationVerifyResponse";
+export * from "./models/api/identity/IIdentityVerificationMethodCreateRequest";
+export * from "./models/api/identity/IIdentityVerificationMethodCreateResponse";
+export * from "./models/api/identity/IIdentityVerificationMethodRemoveRequest";
+export * from "./models/api/profile/IIdentityProfileCreateRequest";
+export * from "./models/api/profile/IIdentityProfileGetPublicRequest";
+export * from "./models/api/profile/IIdentityProfileGetPublicResponse";
+export * from "./models/api/profile/IIdentityProfileGetRequest";
+export * from "./models/api/profile/IIdentityProfileGetResponse";
+export * from "./models/api/profile/IIdentityProfileListRequest";
+export * from "./models/api/profile/IIdentityProfileListResponse";
+export * from "./models/api/profile/IIdentityProfileUpdateRequest";
+export * from "./models/api/resolver/IIdentityResolveRequest";
+export * from "./models/api/resolver/IIdentityResolveResponse";
 export * from "./models/IIdentityComponent";
 export * from "./models/IIdentityConnector";
 export * from "./models/IIdentityProfileComponent";
 export * from "./models/IIdentityProfileConnector";
+export * from "./models/IIdentityResolverComponent";
+export * from "./models/IIdentityResolverConnector";
 export * from "./utils/documentHelper";
+export * from "./utils/verificationHelper";

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

@@ -1,13 +1,142 @@
 import type { IComponent } from "@twin.org/core";
-import type { IDidDocument } from "@twin.org/standards-w3c-did";
+import type { IJsonLdContextDefinitionRoot, IJsonLdNodeObject } from "@twin.org/data-json-ld";
+import type { DidVerificationMethodType, IDidDocument, IDidDocumentVerificationMethod, IProof, IDidService, IDidVerifiableCredential, IDidVerifiablePresentation, ProofTypes } from "@twin.org/standards-w3c-did";
 /**
  * Interface describing a contract which provides identity operations.
  */
 export interface IIdentityComponent extends IComponent {
     /**
-     * Resolve an identity.
-     * @param documentId The id of the document to resolve.
-     * @returns The resolved document.
+     * Create a new identity.
+     * @param namespace The namespace of the connector to use for the identity, defaults to service configured namespace.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The created identity document.
      */
-    resolve(documentId: string): Promise<IDidDocument>;
+    identityCreate(namespace?: string, controller?: string): Promise<IDidDocument>;
+    /**
+     * Remove an identity.
+     * @param identity The id of the document to remove.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     */
+    identityRemove(identity: string, controller?: string): Promise<void>;
+    /**
+     * Add a verification method to the document in JSON Web key Format.
+     * @param identity The id of the document to add the verification method to.
+     * @param verificationMethodType The type of the verification method to add.
+     * @param verificationMethodId The id of the verification method, if undefined uses the kid of the generated JWK.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The verification method.
+     * @throws NotFoundError if the id can not be resolved.
+     * @throws NotSupportedError if the platform does not support multiple keys.
+     */
+    verificationMethodCreate(identity: string, verificationMethodType: DidVerificationMethodType, verificationMethodId?: string, controller?: string): Promise<IDidDocumentVerificationMethod>;
+    /**
+     * Remove a verification method from the document.
+     * @param verificationMethodId The id of the verification method.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     * @throws NotFoundError if the id can not be resolved.
+     * @throws NotSupportedError if the platform does not support multiple revocable keys.
+     */
+    verificationMethodRemove(verificationMethodId: string, controller?: string): Promise<void>;
+    /**
+     * Add a service to the document.
+     * @param identity The id of the document to add the service to.
+     * @param serviceId The id of the service.
+     * @param serviceType The type of the service.
+     * @param serviceEndpoint The endpoint for the service.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The service.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    serviceCreate(identity: string, serviceId: string, serviceType: string | string[], serviceEndpoint: string | string[], controller?: string): Promise<IDidService>;
+    /**
+     * Remove a service from the document.
+     * @param serviceId The id of the service.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    serviceRemove(serviceId: string, controller?: string): Promise<void>;
+    /**
+     * Create a verifiable credential for a verification method.
+     * @param verificationMethodId The verification method id to use.
+     * @param id The id of the credential.
+     * @param subject The credential subject to store in the verifiable credential.
+     * @param revocationIndex The bitmap revocation index of the credential, if undefined will not have revocation status.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The created verifiable credential and its token.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    verifiableCredentialCreate(verificationMethodId: string, id: string | undefined, subject: IJsonLdNodeObject, revocationIndex?: number, controller?: string): Promise<{
+        verifiableCredential: IDidVerifiableCredential;
+        jwt: string;
+    }>;
+    /**
+     * Verify a verifiable credential is valid.
+     * @param credentialJwt The credential to verify.
+     * @returns The credential stored in the jwt and the revocation status.
+     */
+    verifiableCredentialVerify(credentialJwt: string): Promise<{
+        revoked: boolean;
+        verifiableCredential?: IDidVerifiableCredential;
+    }>;
+    /**
+     * Revoke verifiable credential.
+     * @param issuerId The id of the document to update the revocation list for.
+     * @param credentialIndex The revocation bitmap index revoke.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     */
+    verifiableCredentialRevoke(issuerId: string, credentialIndex: number, controller?: string): Promise<void>;
+    /**
+     * Unrevoke verifiable credential.
+     * @param issuerId The id of the document to update the revocation list for.
+     * @param credentialIndex The revocation bitmap index to un revoke.
+     * @param controller The controller of the identity who can make changes.
+     * @returns Nothing.
+     */
+    verifiableCredentialUnrevoke(issuerId: string, credentialIndex: number, controller?: string): Promise<void>;
+    /**
+     * Create a verifiable presentation from the supplied verifiable credentials.
+     * @param verificationMethodId The method to associate with the presentation.
+     * @param presentationId The id of the presentation.
+     * @param contexts The contexts for the data stored in the verifiable credential.
+     * @param types The types for the data stored in the verifiable credential.
+     * @param verifiableCredentials The credentials to use for creating the presentation in jwt format.
+     * @param expiresInMinutes The time in minutes for the presentation to expire.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The created verifiable presentation and its token.
+     * @throws NotFoundError if the id can not be resolved.
+     */
+    verifiablePresentationCreate(verificationMethodId: string, presentationId: string | undefined, contexts: IJsonLdContextDefinitionRoot | undefined, types: string | string[] | undefined, verifiableCredentials: (string | IDidVerifiableCredential)[], expiresInMinutes?: number, controller?: string): Promise<{
+        verifiablePresentation: IDidVerifiablePresentation;
+        jwt: string;
+    }>;
+    /**
+     * Verify a verifiable presentation is valid.
+     * @param presentationJwt The presentation to verify.
+     * @returns The presentation stored in the jwt and the revocation status.
+     */
+    verifiablePresentationVerify(presentationJwt: string): Promise<{
+        revoked: boolean;
+        verifiablePresentation?: IDidVerifiablePresentation;
+        issuers?: IDidDocument[];
+    }>;
+    /**
+     * Create a proof for a document with the specified verification method.
+     * @param verificationMethodId The verification method id to use.
+     * @param proofType The type of proof to create.
+     * @param unsecureDocument The unsecure document to create the proof for.
+     * @param controller The controller of the identity who can make changes.
+     * @returns The proof.
+     */
+    proofCreate(verificationMethodId: string, proofType: ProofTypes, unsecureDocument: IJsonLdNodeObject, controller?: string): Promise<IProof>;
+    /**
+     * Verify proof for a document with the specified verification method.
+     * @param document The document to verify.
+     * @param proof The proof to verify.
+     * @returns True if the proof is verified.
+     */
+    proofVerify(document: IJsonLdNodeObject, proof: IProof): Promise<boolean>;
 }