@mocanetwork/privado-js-sdk 1.0.0

package/src/credentials/credential-wallet.ts

@@ -0,0 +1,353 @@
+import { DID } from '@mocanetwork/moca-iden3';
+import { IDataStorage } from '../storage/interfaces';
+import {
+  W3CCredential,
+  ProofQuery,
+  VerifiableConstants,
+  CredentialStatus,
+  RevocationStatus,
+  CredentialStatusType,
+  State,
+  DisplayMethodType
+} from './../verifiable';
+
+import { JSONSchema } from '../schema-processor';
+import * as uuid from 'uuid';
+import { CredentialStatusResolverRegistry } from './status/resolver';
+import { IssuerResolver } from './status/sparse-merkle-tree';
+import { AgentResolver } from './status/agent-revocation';
+import { CredentialStatusResolveOptions } from './status/resolver';
+import { getUserDIDFromCredential } from './utils';
+import { CredentialRequest } from './models';
+
+/**
+ * Interface to work with credential wallets
+ *
+ * @public
+ * @interface   ICredentialWallet
+ */
+export interface ICredentialWallet {
+  /**
+   * List of W3C Credential
+   *
+   * @returns `Promise<W3CCredential[]`
+   */
+  list(): Promise<W3CCredential[]>;
+  /**
+   * saves W3C credential (upsert)
+   * @param {W3CCredential} credential - credential to save
+   * @returns `Promise<void>`
+   *
+   */
+  save(credential: W3CCredential): Promise<void>;
+  /**
+   * saves the batch of W3C credentials (upsert)
+   * @param {W3CCredential[]} credentials - credentials to save
+   * @returns `Promise<void>`
+   */
+  saveAll(credentials: W3CCredential[]): Promise<void>;
+
+  /**
+   *
+   * removes W3C credentials from data storage
+   * @param {string} id
+   * @returns `Promise<void>`
+   */
+  remove(id: string): Promise<void>;
+  /**
+   * Find credential using iden3 query language
+   *
+   * @param {ProofQuery} query  - protocol query to find credential
+   * @returns `Promise<W3CCredential[]>`
+   */
+  findByQuery(query: ProofQuery): Promise<W3CCredential[]>;
+  /**
+   * Finds the credential by its id
+   *
+   * @param {string} id - id of credential
+   * @returns `Promise<W3CCredential | undefined>`
+   */
+  findById(id: string): Promise<W3CCredential | undefined>;
+  /**
+   * Finds credentials by JSON-LD schema and type
+   *
+   * @param {string} context - the URL of JSON-LD schema where type is defined
+   * @returns `Promise<W3CCredential[]>`
+   */
+  findByContextType(context: string, type: string): Promise<W3CCredential[]>;
+
+  /**
+   * Filters given credentials with given credential subject
+   *
+   * @param {W3CCredential[]} credentials - credentials to filter
+   * @param {DID} subject - credential subject id
+   * @returns `Promise<W3CCredential[]>`
+   */
+  filterByCredentialSubject(credentials: W3CCredential[], subject: DID): Promise<W3CCredential[]>;
+  /**
+   * Finds first non-revoked Auth BJJ credential for given user
+   *
+   * @param {DID} did - the issuer of Auth BJJ credential
+   * @returns `Promise<W3CCredential>` W3CCredential with AuthBJJCredential type
+   */
+  getAuthBJJCredential(did: DID): Promise<W3CCredential>;
+
+  /**
+   * Finds all Auth BJJ credentials for given user
+   *
+   * @param {DID} did - the issuer of Auth BJJ credential
+   * @returns `Promise<W3CCredential[]>` W3CCredentials with AuthBJJCredential type
+   */
+  getAllAuthBJJCredentials(did: DID): Promise<W3CCredential[]>;
+
+  /**
+   * Fetches or Builds a revocation status for a given credential
+   * Supported types for credentialStatus field: SparseMerkleTreeProof, Iden3ReverseSparseMerkleTreeProof
+   *
+   * @param {W3CCredential} cred - credential for which lib should build revocation status
+   * @returns `Promise<RevocationStatus>`
+   */
+  getRevocationStatusFromCredential(cred: W3CCredential): Promise<RevocationStatus>;
+  /**
+   * Fetches Revocation status depended on type
+   *
+   * @param {(CredentialStatus )} credStatus - credentialStatus field of the Verifiable Credential.  Supported types for credentialStatus field: SparseMerkleTreeProof, Iden3ReverseSparseMerkleTreeProof
+   * @param {CredentialStatusResolveOptions} credentialStatusResolveOptions - options to resolve credential status
+   * @returns `Promise<RevocationStatus>`
+   */
+  getRevocationStatus(
+    credStatus: CredentialStatus,
+    credentialStatusResolveOptions?: CredentialStatusResolveOptions
+  ): Promise<RevocationStatus>;
+  /**
+   * Creates a W3C verifiable Credential object
+   *
+   * @param {string} hostUrl - URL that will be used as a prefix for credential identifier
+   * @param {DID} issuer - issuer identity
+   * @param {CredentialRequest} request - specification of claim creation parameters
+   * @param {JSONSchema} schema - JSON schema for W3C Verifiable Credential
+   * @returns W3CCredential
+   */
+  createCredential(issuer: DID, request: CredentialRequest, schema: JSONSchema): W3CCredential;
+
+  /**
+   * Finds non-revoked credential from a given list by resolving their credential status
+   *
+   * @param {W3CCredential[]} creds
+   * @returns `{Promise<{
+   *     cred: W3CCredential;
+   *     revStatus: RevocationStatus;
+   *   }>` not revoked credential and it's revocation status
+   */
+  findNonRevokedCredential(creds: W3CCredential[]): Promise<{
+    cred: W3CCredential;
+    revStatus: RevocationStatus;
+  }>;
+}
+
+/**
+ *
+ * Wallet instance is a wrapper of CRUD logic for W3C credentials,
+ * also it allows to fetch revocation statuses.
+ *
+ * @public
+ * @class CredentialWallet
+ * @implements implements ICredentialWallet interface
+ */
+export class CredentialWallet implements ICredentialWallet {
+  /**
+   * Creates an instance of CredentialWallet.
+   * @param {IDataStorage} _storage - data storage to access credential / identity / Merkle tree data
+   * @param {CredentialStatusResolverRegistry} _credentialStatusResolverRegistry - list of credential status resolvers
+   * if _credentialStatusResolverRegistry is not provided, default resolvers will be used
+   */
+  constructor(
+    private readonly _storage: IDataStorage,
+    private readonly _credentialStatusResolverRegistry?: CredentialStatusResolverRegistry
+  ) {
+    // if no credential status resolvers are provided
+    // register default issuer resolver
+    if (!this._credentialStatusResolverRegistry) {
+      this._credentialStatusResolverRegistry = new CredentialStatusResolverRegistry();
+      this._credentialStatusResolverRegistry.register(
+        CredentialStatusType.SparseMerkleTreeProof,
+        new IssuerResolver()
+      );
+      this._credentialStatusResolverRegistry.register(
+        CredentialStatusType.Iden3commRevocationStatusV1,
+        new AgentResolver()
+      );
+    }
+  }
+
+  /**
+   * {@inheritDoc ICredentialWallet.getAuthBJJCredential}
+   */
+  async getAuthBJJCredential(did: DID): Promise<W3CCredential> {
+    // filter where the issuer of auth credential is given did
+
+    const authBJJCredsOfIssuer = await this._storage.credential.findCredentialsByQuery({
+      context: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD_URL,
+      type: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_TYPE,
+      allowedIssuers: [did.string()]
+    });
+
+    if (!authBJJCredsOfIssuer.length) {
+      throw new Error(VerifiableConstants.ERRORS.NO_AUTH_CRED_FOUND);
+    }
+
+    for (let index = 0; index < authBJJCredsOfIssuer.length; index++) {
+      const authCred = authBJJCredsOfIssuer[index];
+      const revocationStatus = await this.getRevocationStatusFromCredential(authCred);
+
+      if (!revocationStatus.mtp.existence) {
+        return authCred;
+      }
+    }
+    throw new Error('all auth bjj credentials are revoked');
+  }
+
+  /**
+   * {@inheritDoc ICredentialWallet.getAllAuthBJJCredentials}
+   */
+  async getAllAuthBJJCredentials(did: DID): Promise<W3CCredential[]> {
+    return this._storage.credential.findCredentialsByQuery({
+      context: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_SCHEMA_JSONLD_URL,
+      type: VerifiableConstants.AUTH.AUTH_BJJ_CREDENTIAL_TYPE,
+      allowedIssuers: [did.string()]
+    });
+  }
+
+  /**
+   * {@inheritDoc ICredentialWallet.getRevocationStatusFromCredential}
+   */
+  async getRevocationStatusFromCredential(cred: W3CCredential): Promise<RevocationStatus> {
+    const mtpProof = cred.getIden3SparseMerkleTreeProof();
+    const sigProof = cred.getBJJSignature2021Proof();
+
+    const stateInfo: State | undefined = mtpProof
+      ? mtpProof.issuerData.state
+      : sigProof?.issuerData.state;
+    const issuerDID = DID.parse(cred.issuer);
+
+    const userDID = getUserDIDFromCredential(issuerDID, cred);
+
+    const opts: CredentialStatusResolveOptions = {
+      issuerGenesisState: stateInfo,
+      issuerDID,
+      userDID
+    };
+
+    return this.getRevocationStatus(cred.credentialStatus, opts);
+  }
+
+  /**
+   * {@inheritDoc ICredentialWallet.getRevocationStatus}
+   */
+  async getRevocationStatus(
+    credStatus: CredentialStatus,
+    credentialStatusResolveOptions?: CredentialStatusResolveOptions
+  ): Promise<RevocationStatus> {
+    const statusResolver = this._credentialStatusResolverRegistry?.get(credStatus.type);
+    if (!statusResolver) {
+      throw new Error(`credential status resolver does not exist for ${credStatus.type} type`);
+    }
+
+    return statusResolver.resolve(credStatus, credentialStatusResolveOptions);
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.createCredential}
+   */
+  createCredential = (
+    issuer: DID,
+    request: CredentialRequest,
+    schema: JSONSchema
+  ): W3CCredential => {
+    if (!schema.$metadata.uris['jsonLdContext']) {
+      throw new Error('jsonLdContext is missing is the schema');
+    }
+    // do copy of request to avoid mutation
+    const r = { ...request };
+    r.context = r.context ?? [];
+    if (
+      r.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
+      !r.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)
+    ) {
+      r.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
+    }
+    r.context.push(schema.$metadata.uris['jsonLdContext']);
+    r.expiration = r.expiration ? r.expiration * 1000 : undefined;
+    r.id = r.id ? r.id : `urn:${uuid.v4()}`;
+    r.issuanceDate = r.issuanceDate ? r.issuanceDate * 1000 : Date.now();
+
+    return W3CCredential.fromCredentialRequest(issuer, r);
+  };
+
+  /**
+   * {@inheritDoc ICredentialWallet.findById}
+   */
+  async findById(id: string): Promise<W3CCredential | undefined> {
+    return this._storage.credential.findCredentialById(id);
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.findByContextType}
+   */
+  async findByContextType(context: string, type: string): Promise<W3CCredential[]> {
+    return this._storage.credential.findCredentialsByQuery({ context, type });
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.save}
+   */
+  async save(credential: W3CCredential): Promise<void> {
+    return this._storage.credential.saveCredential(credential);
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.saveAll}
+   */
+  async saveAll(credentials: W3CCredential[]): Promise<void> {
+    return this._storage.credential.saveAllCredentials(credentials);
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.remove}
+   */
+  async remove(id: string): Promise<void> {
+    return this._storage.credential.removeCredential(id);
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.list}
+   */
+  async list(): Promise<W3CCredential[]> {
+    return this._storage.credential.listCredentials();
+  }
+  /**
+   * {@inheritDoc ICredentialWallet.findByQuery}
+   */
+  async findByQuery(query: ProofQuery): Promise<W3CCredential[]> {
+    return this._storage.credential.findCredentialsByQuery(query);
+  }
+
+  /**
+   * {@inheritDoc ICredentialWallet.filterByCredentialSubject}
+   */
+  async filterByCredentialSubject(
+    credentials: W3CCredential[],
+    subject: DID
+  ): Promise<W3CCredential[]> {
+    return credentials.filter((cred: W3CCredential) => {
+      return cred.credentialSubject['id'] === subject.string();
+    });
+  }
+  async findNonRevokedCredential(creds: W3CCredential[]): Promise<{
+    cred: W3CCredential;
+    revStatus: RevocationStatus;
+  }> {
+    for (const cred of creds) {
+      const revStatus = await this.getRevocationStatusFromCredential(cred);
+      if (revStatus.mtp.existence) {
+        continue;
+      }
+      return { cred, revStatus };
+    }
+    throw new Error(VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
+  }
+}

package/src/credentials/index.ts

@@ -0,0 +1,11 @@
+export * from './status/on-chain-revocation';
+export * from './status/reverse-sparse-merkle-tree';
+export * from './status/sparse-merkle-tree';
+export * from './status/resolver';
+export * from './status/agent-revocation';
+export * from './status/credential-status-publisher';
+export * from './status/did-resolver-revocation';
+export * from './credential-wallet';
+export * from './rhs';
+export * from './utils';
+export * from './models';

package/src/credentials/models.ts

@@ -0,0 +1,93 @@
+import { JsonDocumentObject } from '../iden3comm';
+import {
+  CredentialStatusType,
+  DisplayMethod,
+  MerklizedRootPosition,
+  RefreshService,
+  SubjectPosition
+} from '../verifiable';
+
+/**
+ * Represents the publish mode for identity wallet.
+ * It can be one of the following values: 'sync', 'async', or 'callback'.
+ * 'sync' - publish the status synchronously
+ * 'async' - publish the status asynchronously via message bus
+ * 'callback' - publish the status with a txCallback
+ */
+export type PublishMode = 'sync' | 'async' | 'callback';
+
+/**
+ * Request to core library to create Core Claim from W3C Verifiable Credential
+ *
+ * @public
+ * @interface CredentialRequest
+ */
+export interface CredentialRequest {
+  /**
+   * Credential ID
+   */
+  id?: string;
+  /**
+   * JSON credential schema
+   */
+  credentialSchema: string;
+  /**
+   * Credential type
+   */
+  type: string;
+  /**
+   * Credential subject, usually contains claims and identifier
+   */
+  credentialSubject: JsonDocumentObject;
+  /**
+   * expiration time
+   */
+  expiration?: number;
+  /**
+   * refreshService
+   */
+  refreshService?: RefreshService;
+  /**
+   * displayMethod
+   */
+  displayMethod?: DisplayMethod;
+  /**
+   * optional custom context
+   */
+  context?: string[];
+  /**
+   * claim version
+   */
+  version?: number;
+
+  /**
+   * subject position (index / value / none)
+   */
+  subjectPosition?: SubjectPosition;
+  /**
+   * merklizedRootPosition (index / value / none)
+   */
+  merklizedRootPosition?: MerklizedRootPosition;
+  /**
+   * issuance Date
+   */
+  issuanceDate?: number;
+
+  /**
+   * Revocation options
+   *
+   * @type {{
+   *     id: string;
+   *     nonce?: number;
+   *     type: CredentialStatusType;
+   *     issuerState?: string;
+   *   }}
+   * @memberof CredentialRequest
+   */
+  revocationOpts: {
+    id: string;
+    nonce?: number;
+    type: CredentialStatusType;
+    issuerState?: string;
+  };
+}

package/src/credentials/rhs.ts

@@ -0,0 +1,176 @@
+import { Hash, testBit, Merkletree, NodeLeaf, Siblings } from '@iden3/js-merkletree';
+
+import { NODE_TYPE_LEAF } from '@iden3/js-merkletree';
+import { hashElems } from '@iden3/js-merkletree';
+import { ProofNode } from './status/reverse-sparse-merkle-tree';
+import { Iden3SmtRhsCredentialStatusPublisher } from './status/credential-status-publisher';
+import { CredentialStatusType } from '../verifiable';
+/**
+ * Interface to unite contains three trees: claim, revocation and rootOfRoots
+ * Also contains the current state of identity
+ * @public
+ * @interface TreesModel
+ */
+export interface TreesModel {
+  claimsTree: Merkletree;
+  revocationTree: Merkletree;
+  rootsTree: Merkletree;
+  state: Hash;
+}
+
+/**
+ * Pushes identity state information to a reverse hash service.
+ *
+ * A reverse hash service (RHS) is a centralized or decentralized service for storing publicly available data about identity.
+ * Such data are identity state and state of revocation tree and roots tree root tree.
+ *
+ * @deprecated Use `pushHashesToReverseHashService` instead.
+ * @param {Hash} state - current state of identity
+ * @param {TreesModel} trees - current trees of identity (claims, revocation, rootOfRoots )
+ * @param {string} rhsUrl - URL of service
+ * @param {number[]} [revokedNonces] - revoked nonces since last published info
+ * @returns void
+ */
+export async function pushHashesToRHS(
+  state: Hash,
+  trees: TreesModel,
+  rhsUrl: string,
+  revokedNonces?: number[]
+): Promise<void> {
+  const nodes = await getNodesRepresentation(revokedNonces, trees, state);
+  const publisher = new Iden3SmtRhsCredentialStatusPublisher();
+  await publisher.publish({
+    nodes,
+    credentialStatusType: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
+    rhsUrl: rhsUrl
+  });
+}
+
+/**
+ * Retrieves the representation of nodes for generating a proof.
+ *
+ * @param revokedNonces - An array of revoked nonces.
+ * @param trees - The TreesModel object containing the necessary trees.
+ * @param state - The hash of the state.
+ * @returns A Promise that resolves to an array of ProofNode objects.
+ */
+export async function getNodesRepresentation(
+  revokedNonces: number[] | undefined,
+  trees: TreesModel,
+  state: Hash
+): Promise<ProofNode[]> {
+  const nb = new NodesBuilder();
+
+  if (revokedNonces) {
+    await addRevocationNode(nb, trees, revokedNonces);
+  }
+
+  await addRoRNode(nb, trees);
+
+  // add new state node
+  if (!state.bytes.every((b) => b === 0)) {
+    nb.addProofNode(
+      new ProofNode(state, [
+        await trees.claimsTree.root(),
+        await trees.revocationTree.root(),
+        await trees.rootsTree.root()
+      ])
+    );
+  }
+
+  return nb.nodes;
+}
+
+async function addRoRNode(nb: NodesBuilder, trees: TreesModel): Promise<void> {
+  const currentRootsTree = trees.rootsTree;
+  const claimsTree = trees.claimsTree;
+
+  return nb.addKey(currentRootsTree, (await claimsTree.root()).bigInt());
+}
+
+async function addRevocationNode(
+  nb: NodesBuilder,
+  trees: TreesModel,
+  revokedNonces: number[]
+): Promise<void> {
+  const revocationTree = trees.revocationTree;
+
+  for (const nonce of revokedNonces) {
+    await nb.addKey(revocationTree, BigInt(nonce));
+  }
+}
+
+/**
+ * Builder to send state information to Reverse hash Service
+ *
+ * @public
+ * @class NodesBuilder
+ */
+class NodesBuilder {
+  constructor(
+    public readonly nodes: ProofNode[] = [],
+    public readonly seen: Map<string, boolean> = new Map()
+  ) {}
+
+  async addKey(tree: Merkletree, nodeKey: bigint): Promise<void> {
+    const { value: nodeValue, siblings } = await tree.get(nodeKey);
+
+    const nodeKeyHash = Hash.fromBigInt(nodeKey);
+
+    const nodeValueHash = Hash.fromBigInt(nodeValue);
+
+    const node = new NodeLeaf(nodeKeyHash, nodeValueHash);
+    const newNodes: ProofNode[] = await buildNodesUp(siblings, node);
+
+    for (const n of newNodes) {
+      if (!this.seen.get(n.hash.hex())) {
+        this.nodes.push(n);
+        this.seen.set(n.hash.hex(), true);
+      }
+    }
+  }
+
+  addProofNode(node: ProofNode): void {
+    const hex = node.hash.hex();
+    const isSeen = this.seen.get(hex);
+    if (!isSeen) {
+      this.nodes.push(node);
+      this.seen.set(hex, true);
+    }
+  }
+}
+
+async function buildNodesUp(siblings: Siblings, node: NodeLeaf): Promise<ProofNode[]> {
+  if (node.type !== NODE_TYPE_LEAF) {
+    throw new Error('node is not a leaf');
+  }
+
+  let prevHash = await node.getKey();
+  const sl = siblings.length;
+  const nodes = new Array<ProofNode>(sl + 1);
+  for (let index = 0; index < nodes.length; index++) {
+    nodes[index] = new ProofNode();
+  }
+  nodes[sl].hash = prevHash;
+  const hashOfOne = Hash.fromBigInt(BigInt(1));
+
+  nodes[sl].children = [node.entry[0], node.entry[1], hashOfOne];
+
+  const pathKey: Hash = node.entry[0];
+  for (let i = sl - 1; i >= 0; i--) {
+    const isRight = testBit(pathKey.bytes, i);
+    nodes[i].children = new Array<Hash>(2);
+    if (isRight) {
+      nodes[i].children[0] = siblings[i];
+      nodes[i].children[1] = prevHash;
+    } else {
+      nodes[i].children[0] = prevHash;
+      nodes[i].children[1] = siblings[i];
+    }
+    nodes[i].hash = hashElems([nodes[i].children[0].bigInt(), nodes[i].children[1].bigInt()]);
+
+    prevHash = nodes[i].hash;
+  }
+
+  return nodes;
+}

package/src/credentials/status/agent-revocation.ts

@@ -0,0 +1,69 @@
+import { CredentialStatus, RevocationStatus } from '../../verifiable';
+import { CredentialStatusResolver, CredentialStatusResolveOptions } from './resolver';
+import { RevocationStatusRequestMessage } from '../../iden3comm/types';
+import { MediaType, PROTOCOL_MESSAGE_TYPE } from '../../iden3comm/constants';
+import * as uuid from 'uuid';
+import { toRevocationStatus } from './sparse-merkle-tree';
+
+/**
+ * AgentResolver is a class that allows to interact with the issuer's agent to get revocation status.
+ *
+ * @public
+ * @class AgentResolver
+ */
+export class AgentResolver implements CredentialStatusResolver {
+  /**
+   * resolve is a method to resolve a credential status from an agent.
+   *
+   * @public
+   * @param {CredentialStatus} credentialStatus -  credential status to resolve
+   * @param {CredentialStatusResolveOptions} credentialStatusResolveOptions -  options for resolver
+   * @returns `{Promise<RevocationStatus>}`
+   */
+  async resolve(
+    credentialStatus: CredentialStatus,
+    credentialStatusResolveOptions?: CredentialStatusResolveOptions
+  ): Promise<RevocationStatus> {
+    if (!credentialStatusResolveOptions?.issuerDID) {
+      throw new Error('IssuerDID is not set in options');
+    }
+    if (!credentialStatusResolveOptions?.userDID) {
+      throw new Error('UserDID is not set in options');
+    }
+
+    if (typeof credentialStatus.revocationNonce !== 'number') {
+      throw new Error('Revocation nonce is not set in credential status');
+    }
+
+    const from = credentialStatusResolveOptions.userDID.string();
+    const to = credentialStatusResolveOptions.issuerDID.string();
+    const msg = buildRevocationMessageRequest(from, to, credentialStatus.revocationNonce);
+    const response = await fetch(credentialStatus.id, {
+      method: 'POST',
+      body: JSON.stringify(msg),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    const agentResponse = await response.json();
+    return toRevocationStatus(agentResponse.body);
+  }
+}
+
+function buildRevocationMessageRequest(
+  from: string,
+  to: string,
+  revocationNonce: number
+): RevocationStatusRequestMessage {
+  return {
+    id: uuid.v4(),
+    typ: MediaType.PlainMessage,
+    type: PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE,
+    body: {
+      revocation_nonce: revocationNonce
+    },
+    thid: uuid.v4(),
+    from: from,
+    to: to
+  };
+}