@mocanetwork/privado-js-sdk 1.0.0

package/src/credentials/status/credential-status-publisher.ts

@@ -0,0 +1,143 @@
+import { TransactionReceipt } from 'ethers';
+import { JSONObject } from '../../iden3comm';
+import { OnChainRevocationStorage } from '../../storage';
+import { CredentialStatusType } from '../../verifiable';
+import { ProofNode } from './reverse-sparse-merkle-tree';
+import { MessageBus, SDK_EVENTS } from '../../utils';
+import { PublishMode } from '../models';
+
+/**
+ * Represents a credential status publisher.
+ */
+export interface ICredentialStatusPublisher {
+  /**
+   * Publishes the credential status.
+   * @param params - The parameters for publishing the status.
+   * @returns A promise that resolves when the status is published.
+   */
+  publish(params: JSONObject): Promise<void>;
+}
+
+/**
+ * Registry for managing credential status publishers.
+ */
+export class CredentialStatusPublisherRegistry {
+  private _publishers: Map<CredentialStatusType, ICredentialStatusPublisher[]> = new Map();
+
+  /**
+   * Registers one or more credential status publishers for a given type.
+   * @param type - The credential status type.
+   * @param publisher - One or more credential status publishers.
+   */
+  public register(type: CredentialStatusType, ...publisher: ICredentialStatusPublisher[]): void {
+    const publishers = this._publishers.get(type) ?? [];
+    publishers.push(...publisher);
+    this._publishers.set(type, publishers);
+  }
+
+  /**
+   * Retrieves the credential status publishers for a given type.
+   * @param type - The credential status type.
+   * @returns An array of credential status publishers or undefined if none are registered for the given type.
+   */
+  public get(type: CredentialStatusType): ICredentialStatusPublisher[] | undefined {
+    return this._publishers.get(type);
+  }
+}
+
+/**
+ * Implementation of the ICredentialStatusPublisher interface for publishing on-chain credential status.
+ */
+export class Iden3OnchainSmtCredentialStatusPublisher implements ICredentialStatusPublisher {
+  constructor(private readonly _storage: OnChainRevocationStorage) {}
+
+  /**
+   * Publishes the credential status to the blockchain.
+   * @param params - The parameters for publishing the credential status.
+   */
+  public async publish(params: {
+    nodes: ProofNode[];
+    credentialStatusType: CredentialStatusType;
+    onChain?: {
+      txCallback?: (tx: TransactionReceipt) => Promise<void>;
+      publishMode?: PublishMode;
+    };
+  }): Promise<void> {
+    if (
+      ![CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023].includes(
+        params.credentialStatusType
+      )
+    ) {
+      throw new Error(
+        `On-chain publishing is not supported for credential status type ${params.credentialStatusType}`
+      );
+    }
+    const nodesBigInts = params.nodes.map((n) => n.children.map((c) => c.bigInt()));
+
+    const txPromise = this._storage.saveNodes(nodesBigInts);
+
+    let publishMode = params.onChain?.publishMode ?? 'sync';
+    if (params.onChain?.txCallback) {
+      publishMode = 'callback';
+    }
+
+    switch (publishMode) {
+      case 'sync':
+        await txPromise;
+        break;
+      case 'callback': {
+        if (!params.onChain?.txCallback) {
+          throw new Error('txCallback is required for publishMode "callback"');
+        }
+        const cb = params.onChain?.txCallback;
+        txPromise.then((receipt) => cb(receipt));
+        break;
+      }
+      case 'async': {
+        const mb = MessageBus.getInstance();
+        txPromise.then((receipt) => mb.publish(SDK_EVENTS.TX_RECEIPT_ACCEPTED, receipt));
+        break;
+      }
+      default:
+        throw new Error(`Invalid publishMode: ${publishMode}`);
+    }
+  }
+}
+
+/**
+ * Implementation of the ICredentialStatusPublisher interface for publishing off-chain credential status.
+ */
+export class Iden3SmtRhsCredentialStatusPublisher implements ICredentialStatusPublisher {
+  /**
+   * Publishes the credential status to a specified node URL.
+   * @param params - The parameters for publishing the credential status.
+   * @param params.nodes - The proof nodes to be published.
+   * @param params.rhsUrl - The URL of the node to publish the credential status to.
+   * @returns A promise that resolves when the credential status is successfully published.
+   * @throws An error if the publishing fails.
+   */
+  public async publish(params: {
+    nodes: ProofNode[];
+    credentialStatusType: CredentialStatusType;
+
+    rhsUrl: string;
+  }): Promise<void> {
+    if (
+      ![CredentialStatusType.Iden3ReverseSparseMerkleTreeProof].includes(
+        params.credentialStatusType
+      )
+    ) {
+      throw new Error(
+        `On-chain publishing is not supported for credential status type ${params.credentialStatusType}`
+      );
+    }
+    const nodesJSON = params.nodes.map((n) => n.toJSON());
+    const resp = await fetch(params.rhsUrl + '/node', {
+      method: 'post',
+      body: JSON.stringify(nodesJSON)
+    });
+    if (resp.status !== 200) {
+      throw new Error(`Failed to publish credential status. Status: ${resp.status}`);
+    }
+  }
+}

package/src/credentials/status/did-resolver-revocation.ts

@@ -0,0 +1,24 @@
+import { CredentialStatus, RevocationStatus } from '../../verifiable';
+import { CredentialStatusResolveOptions, CredentialStatusResolver } from './resolver';
+
+export class DidDocumentCredentialStatusResolver implements CredentialStatusResolver {
+  constructor(private readonly didResolverUrl: string) {}
+  async resolve(
+    credentialStatus: CredentialStatus,
+    opts?: CredentialStatusResolveOptions | undefined
+  ): Promise<RevocationStatus> {
+    if (!opts?.issuerDID) {
+      throw new Error('IssuerDID is not set in options');
+    }
+
+    const url = `${this.didResolverUrl}/1.0/credential-status/${encodeURIComponent(
+      opts.issuerDID.string()
+    )}`;
+    const resp = await fetch(url, {
+      method: 'POST',
+      body: JSON.stringify(credentialStatus)
+    });
+    const data = await resp.json();
+    return data;
+  }
+}

package/src/credentials/status/on-chain-revocation.ts

@@ -0,0 +1,174 @@
+import { RevocationStatus, CredentialStatus } from '../../verifiable';
+import { EthConnectionConfig } from '../../storage/blockchain';
+import { CredentialStatusResolver, CredentialStatusResolveOptions } from './resolver';
+import { OnChainRevocationStorage } from '../../storage/blockchain/onchain-revocation';
+import { DID } from '@mocanetwork/moca-iden3';
+import { isGenesisState } from '../../utils';
+import { EthStateStorage, EthStateStorageOptions } from '../../storage/blockchain/state';
+import { IStateStorage, IOnchainRevocationStore } from '../../storage';
+import { Hash } from '@iden3/js-merkletree';
+import { isIdentityDoesNotExistError } from '../../storage/blockchain/errors';
+
+/*
+ * Options for OnChainResolver
+ *
+ * @public
+ * @typedef {Object} OnChainResolverOptions
+ * @property {EthStateStorageOptions} [stateStorageOptions] - options for state storage
+ */
+export type OnChainResolverOptions = {
+  stateStorageOptions?: EthStateStorageOptions;
+};
+
+/**
+ * OnChainIssuer is a class that allows to interact with the onchain contract
+ * and build the revocation status.
+ *
+ * @public
+ * @class OnChainIssuer
+ */
+export class OnChainResolver implements CredentialStatusResolver {
+  private readonly _stateStorage: IStateStorage;
+  /**
+   *
+   * Creates an instance of OnChainIssuer.
+   * @public
+   * @param {Array<EthConnectionConfig>} _configs - list of ethereum network connections
+   */
+  constructor(private readonly _configs: EthConnectionConfig[], _opts?: OnChainResolverOptions) {
+    this._stateStorage = new EthStateStorage(_configs, _opts?.stateStorageOptions);
+  }
+
+  /**
+   * resolve is a method to resolve a credential status from the blockchain.
+   *
+   * @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');
+    }
+    return this.getRevocationOnChain(credentialStatus, credentialStatusResolveOptions.issuerDID);
+  }
+
+  /**
+   * Gets partial revocation status info from onchain issuer contract.
+   *
+   * @param {CredentialStatus} credentialStatus - credential status section of credential
+   * @param {DID} issuerDid - issuer did
+   * @returns `{Promise<RevocationStatus>}`
+   */
+  async getRevocationOnChain(
+    credentialStatus: CredentialStatus,
+    issuer: DID
+  ): Promise<RevocationStatus> {
+    const { contractAddress, chainId, revocationNonce, stateHex } =
+      this.extractCredentialStatusInfo(credentialStatus);
+    if (revocationNonce !== credentialStatus.revocationNonce) {
+      throw new Error('revocationNonce does not match');
+    }
+
+    const issuerId = DID.idFromDID(issuer);
+    let latestIssuerState: bigint;
+    try {
+      const latestStateInfo = await this._stateStorage.getLatestStateById(issuerId.bigInt());
+      if (!latestStateInfo.state) {
+        throw new Error('state contract returned empty state');
+      }
+      latestIssuerState = latestStateInfo.state;
+    } catch (e) {
+      if (!isIdentityDoesNotExistError(e)) {
+        throw e;
+      }
+
+      if (!stateHex) {
+        throw new Error(
+          'latest state not found and state parameter is not present in credentialStatus.id'
+        );
+      }
+      const stateBigInt = Hash.fromHex(stateHex).bigInt();
+      if (!isGenesisState(issuer, stateBigInt)) {
+        throw new Error(
+          `latest state not found and state parameter ${stateHex} is not genesis state`
+        );
+      }
+      latestIssuerState = stateBigInt;
+    }
+
+    const id = DID.idFromDID(issuer);
+    const onChainCaller = this._getOnChainRevocationStorageForIssuer(chainId, contractAddress);
+    const revocationStatus = await onChainCaller.getRevocationStatusByIdAndState(
+      id.bigInt(),
+      latestIssuerState,
+      revocationNonce
+    );
+    return revocationStatus;
+  }
+
+  /**
+   * Extract information about credential status
+   *
+   * @param {credentialStatus} CredentialStatus - credential status
+   * @returns {{contractAddress: string, chainId: number, revocationNonce: number, issuer: string;}}
+   */
+  extractCredentialStatusInfo(credentialStatus: CredentialStatus): {
+    contractAddress: string;
+    chainId: number;
+    revocationNonce: number;
+    stateHex: string;
+  } {
+    if (!credentialStatus.id) {
+      throw new Error('credentialStatus id is empty');
+    }
+
+    const idParts = credentialStatus.id.split('/');
+    if (idParts.length !== 2) {
+      throw new Error('invalid credentialStatus id');
+    }
+
+    const idURL = new URL(credentialStatus.id);
+    const stateHex = idURL.searchParams.get('state') || '';
+    const contractIdentifier = idURL.searchParams.get('contractAddress');
+    if (!contractIdentifier) {
+      throw new Error('contractAddress not found in credentialStatus.id field');
+    }
+    const parts = contractIdentifier.split(':');
+    if (parts.length != 2) {
+      throw new Error('invalid contract address encoding. should be chainId:contractAddress');
+    }
+    const chainId = parseInt(parts[0], 10);
+    const contractAddress = parts[1];
+
+    // if revocationNonce is not present in id as param, then it should be extract from credentialStatus
+    const rv = idURL.searchParams.get('revocationNonce') || credentialStatus.revocationNonce;
+    if (rv === undefined || rv === null) {
+      throw new Error('revocationNonce not found in credentialStatus id field');
+    }
+    const revocationNonce = typeof rv === 'number' ? rv : parseInt(rv, 10);
+
+    return { contractAddress, chainId, revocationNonce, stateHex };
+  }
+
+  networkByChainId(chainId: number): EthConnectionConfig {
+    const network = this._configs.find((c) => c.chainId === chainId);
+    if (!network) {
+      throw new Error(`chainId "${chainId}" not supported`);
+    }
+    return network;
+  }
+
+  private _getOnChainRevocationStorageForIssuer(
+    chainId: number,
+    contractAddress: string
+  ): IOnchainRevocationStore {
+    const networkConfig = this.networkByChainId(chainId);
+    const onChainCaller = new OnChainRevocationStorage(networkConfig, contractAddress);
+    return onChainCaller;
+  }
+}

package/src/credentials/status/resolver.ts

@@ -0,0 +1,81 @@
+import { DID } from '@mocanetwork/moca-iden3';
+import { State, RevocationStatus, CredentialStatus, CredentialStatusType } from '../../verifiable';
+
+/**
+ * CredentialStatusResolveOptions is a set of options that can be passed to CredentialStatusResolver
+ *
+ * @public
+ * @interface CredentialStatusResolveOptions
+ */
+export interface CredentialStatusResolveOptions {
+  /** 
+    @deprecated  it was used only for state in case issuer has a issuerGenesisState state
+  */
+  issuerData?: {
+    state: {
+      rootOfRoots: string;
+      claimsTreeRoot: string;
+      revocationTreeRoot: string;
+      value: string;
+    };
+  };
+
+  issuerGenesisState?: State;
+  issuerDID?: DID;
+  userDID?: DID;
+}
+
+/**
+ * CredentialStatusResolver is an interface that allows to interact with different types of credential status
+ * to resolve revocation status
+ *
+ * @public
+ * @interface CredentialStatusResolver
+ */
+export interface CredentialStatusResolver {
+  /**
+   * resolve is a method to resolve a credential status from the the specific source.
+   *
+   * @public
+   * @param {CredentialStatus} credentialStatus -  credential status to resolve
+   * @param {CredentialStatusResolveOptions} credentialStatusResolveOptions -  options for resolver
+   * @returns `{Promise<RevocationStatus>}`
+   */
+  resolve(
+    credentialStatus: CredentialStatus,
+    opts?: CredentialStatusResolveOptions
+  ): Promise<RevocationStatus>;
+}
+
+/**
+ * CredentialStatusResolverRegistry is a registry of CredentialStatusResolver
+ *
+ * @public
+ * @interface CredentialStatusResolverRegistry
+ */
+export class CredentialStatusResolverRegistry {
+  private resolvers: Map<CredentialStatusType, CredentialStatusResolver> = new Map();
+
+  /**
+   * register is a method to add a credential status resolver for specific credential status type
+   *
+   * @public
+   * @param {CredentialStatusType} type -  one of the credential status types
+   * @param {CredentialStatusResolver} resolver -  resolver
+   */
+  register(type: CredentialStatusType, resolver: CredentialStatusResolver) {
+    this.resolvers.set(type, resolver);
+  }
+
+  /**
+   * resolve is a method to resolve a credential status from the the specific source.
+   *
+   * @public
+   * @param {CredentialStatus} credentialStatus -  credential status to resolve
+   * @param {CredentialStatusResolveOptions} credentialStatusResolveOptions -  options for resolver
+   * @returns `{Promise<RevocationStatus>}`
+   */
+  get(type: CredentialStatusType): CredentialStatusResolver | undefined {
+    return this.resolvers.get(type);
+  }
+}