@mocanetwork/privado-js-sdk 1.0.0

package/src/iden3comm/handlers/problem-report.ts

@@ -0,0 +1,41 @@
+import * as uuid from 'uuid';
+import { ProblemReportMessage } from '../types/protocol/problem-report';
+import { MediaType, PROTOCOL_MESSAGE_TYPE } from '../constants';
+
+/**
+ * @beta
+ * createProblemReportMessage is a function to create didcomm protocol problem report message
+ * @param pthid - parent thread id
+ * @param code - problem report code
+ * @param opts - problem report options
+ * @returns `ProblemReportMessage`
+ */
+export function createProblemReportMessage(
+  pthid: string,
+  code: string,
+  opts?: {
+    comment?: string;
+    ack?: string[];
+    args?: string[];
+    escalate_to?: string;
+    from?: string;
+    to?: string;
+  }
+): ProblemReportMessage {
+  const uuidv4 = uuid.v4();
+  return {
+    id: uuidv4,
+    pthid: pthid,
+    typ: MediaType.PlainMessage,
+    type: PROTOCOL_MESSAGE_TYPE.PROBLEM_REPORT_MESSAGE_TYPE,
+    ack: opts?.ack,
+    body: {
+      code: code,
+      comment: opts?.comment,
+      args: opts?.args,
+      escalate_to: opts?.escalate_to
+    },
+    from: opts?.from,
+    to: opts?.to
+  };
+}

package/src/iden3comm/handlers/refresh.ts

@@ -0,0 +1,138 @@
+import { MediaType } from '../constants';
+import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+
+import {
+  CredentialIssuanceMessage,
+  CredentialRefreshMessage,
+  IPackageManager,
+  ZKPPackerParams
+} from '../types';
+
+import { RefreshServiceType, W3CCredential } from '../../verifiable';
+import { byteEncoder } from '../../utils';
+import { proving, ProvingMethodAlg } from '@iden3/js-jwz';
+import { DID } from '@mocanetwork/moca-iden3';
+import { ICredentialWallet } from '../../credentials';
+import { CircuitId } from '../../circuits';
+import * as uuid from 'uuid';
+
+/**
+ * RefreshHandlerOptions contains options for RefreshHandler
+ * @public
+ * @interface   RefreshHandlerOptions
+ */
+export interface RefreshHandlerOptions {
+  packageManager: IPackageManager;
+  credentialWallet?: ICredentialWallet;
+}
+
+/**
+ *
+ * RefreshOptions contains options for refreshCredential call
+ *
+ * @public
+ * @interface RefreshOptions
+ */
+export interface RefreshOptions {
+  reason?: string;
+}
+
+/**
+ * Interface to work with credential refresh handler
+ *
+ * @public
+ * @interface IRefreshHandler
+ */
+export interface IRefreshHandler {
+  /**
+   * refresh credential
+   *
+   * @param {W3CCredential} credential - credential to refresh
+   * @param {RefreshOptions} opts - options
+   * @returns {Promise<W3CCredential>}
+   */
+  refreshCredential(credential: W3CCredential, opts?: RefreshOptions): Promise<W3CCredential>;
+}
+/**
+ *
+ * Allows to refresh credential from refresh service and return refreshed credential
+ *
+ * @public
+
+ * @class RefreshHandler
+ * @implements implements RefreshHandler interface
+ */
+export class RefreshHandler implements IRefreshHandler {
+  /**
+   * Creates an instance of RefreshHandler.
+   * @param {RefreshHandlerOptions} _options - refresh handler options
+   */
+  constructor(private readonly _options: RefreshHandlerOptions) {}
+
+  async refreshCredential(
+    credential: W3CCredential,
+    opts?: RefreshOptions
+  ): Promise<W3CCredential> {
+    if (!credential.refreshService) {
+      throw new Error('refreshService not specified for W3CCredential');
+    }
+    if (credential.refreshService.type !== RefreshServiceType.Iden3RefreshService2023) {
+      throw new Error(`refresh service type ${credential.refreshService.type} is not supported`);
+    }
+
+    const otherIdentifier = credential.credentialSubject.id as string;
+
+    if (!otherIdentifier) {
+      throw new Error('self credentials do not support refresh');
+    }
+
+    const senderDID = DID.parse(otherIdentifier);
+
+    const zkpParams: ZKPPackerParams = {
+      senderDID,
+      provingMethodAlg: new ProvingMethodAlg(
+        proving.provingMethodGroth16AuthV2Instance.methodAlg.alg,
+        CircuitId.AuthV2
+      )
+    };
+
+    const refreshMsg: CredentialRefreshMessage = {
+      id: uuid.v4(),
+      typ: MediaType.ZKPMessage,
+      type: PROTOCOL_MESSAGE_TYPE.CREDENTIAL_REFRESH_MESSAGE_TYPE,
+      thid: uuid.v4(),
+      body: {
+        id: credential.id,
+        reason: opts?.reason ?? 'credential is expired'
+      },
+      from: otherIdentifier,
+      to: credential.issuer
+    };
+
+    const msgBytes = byteEncoder.encode(JSON.stringify(refreshMsg));
+    const jwzToken = await this._options.packageManager.pack(
+      MediaType.ZKPMessage,
+      msgBytes,
+      zkpParams
+    );
+    const resp = await fetch(credential.refreshService.id, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: jwzToken
+    });
+
+    if (resp.status !== 200) {
+      throw new Error(`could not refresh W3C credential, return status ${resp.status}`);
+    }
+
+    const respBody: CredentialIssuanceMessage = await resp.json();
+
+    if (!respBody.body?.credential) {
+      throw new Error('no credential in CredentialIssuanceMessage response');
+    }
+
+    return W3CCredential.fromJSON(respBody.body.credential);
+  }
+}

package/src/iden3comm/handlers/revocation-status.ts

@@ -0,0 +1,228 @@
+import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { MediaType } from '../constants';
+import {
+  BasicMessage,
+  IPackageManager,
+  JWSPackerParams,
+  RevocationStatusRequestMessage,
+  RevocationStatusResponseMessage
+} from '../types';
+
+import { DID } from '@mocanetwork/moca-iden3';
+import * as uuid from 'uuid';
+import { RevocationStatus } from '../../verifiable';
+import { TreeState } from '../../circuits';
+import { byteEncoder } from '../../utils';
+import { proving } from '@iden3/js-jwz';
+import { IIdentityWallet } from '../../identity';
+import {
+  AbstractMessageHandler,
+  BasicHandlerOptions,
+  IProtocolMessageHandler
+} from './message-handler';
+import { verifyExpiresTime } from './common';
+
+/**
+ * Defines the options for a RevocationStatusMessageHandler.
+ * @property senderDid - The DID (Decentralized Identifier) to be used.
+ * @property mediaType - The media type to be used.
+ * @property packerOptions - Optional parameters for the JWS packer.
+ * @property treeState - Optional tree state to be used.
+ */
+export type RevocationStatusMessageHandlerOptions = {
+  senderDid: DID;
+  mediaType: MediaType;
+  packerOptions?: JWSPackerParams;
+  treeState?: TreeState;
+};
+
+/**
+ * Interface that allows the processing of the revocation status
+ *
+ * @interface IRevocationStatusHandler
+ */
+export interface IRevocationStatusHandler {
+  /**
+   * unpacks revocation status request
+   * @param {Uint8Array} request - raw byte message
+   * @returns `Promise<RevocationStatusRequestMessage>`
+   */
+  parseRevocationStatusRequest(request: Uint8Array): Promise<RevocationStatusRequestMessage>;
+
+  /**
+   * handle revocation status request
+   * @param {did} did  - sender DID
+   * @param {Uint8Array} request - raw byte message
+   * @param {RevocationStatusHandlerOptions} opts - handler options
+   * @returns {Promise<Uint8Array>}` - revocation status response message
+   */
+  handleRevocationStatusRequest(
+    did: DID,
+    request: Uint8Array,
+    opts?: RevocationStatusHandlerOptions
+  ): Promise<Uint8Array>;
+}
+
+/** RevocationStatusHandlerOptions represents revocation status handler options */
+export type RevocationStatusHandlerOptions = BasicHandlerOptions & {
+  mediaType: MediaType;
+  packerOptions?: JWSPackerParams;
+  treeState?: TreeState;
+};
+
+/**
+ *
+ * Allows to process RevocationStatusRequest protocol message
+ *
+
+ * @class RevocationStatusHandler
+ * @implements implements IRevocationStatusHandler interface
+ */
+export class RevocationStatusHandler
+  extends AbstractMessageHandler
+  implements IRevocationStatusHandler, IProtocolMessageHandler
+{
+  /**
+   * Creates an instance of RevocationStatusHandler.
+   * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+   * @param {IIdentityWallet} _identityWallet - identity wallet
+   *
+   */
+  constructor(
+    private readonly _packerMgr: IPackageManager,
+    private readonly _identityWallet: IIdentityWallet
+  ) {
+    super();
+  }
+
+  public handle(
+    message: BasicMessage,
+    context: RevocationStatusMessageHandlerOptions
+  ): Promise<BasicMessage | null> {
+    if (!context.senderDid) {
+      throw new Error('DID is required');
+    }
+
+    if (!context.mediaType) {
+      throw new Error('mediaType is required');
+    }
+
+    switch (message.type) {
+      case PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE:
+        return this.handleRevocationStatusRequestMessage(
+          message as RevocationStatusRequestMessage,
+          context
+        );
+      default:
+        return super.handle(message, context);
+    }
+  }
+
+  private async handleRevocationStatusRequestMessage(
+    rsRequest: RevocationStatusRequestMessage,
+    context: RevocationStatusMessageHandlerOptions
+  ): Promise<BasicMessage | null> {
+    if (!rsRequest.to) {
+      throw new Error(`failed request. empty 'to' field`);
+    }
+
+    if (!rsRequest.from) {
+      throw new Error(`failed request. empty 'from' field`);
+    }
+
+    if (!rsRequest.body?.revocation_nonce) {
+      throw new Error(`failed request. empty 'revocation_nonce' field`);
+    }
+
+    const issuerDID = DID.parse(rsRequest.to);
+
+    const mtpWithTreeState = await this._identityWallet.generateNonRevocationMtpWithNonce(
+      issuerDID,
+      BigInt(rsRequest.body.revocation_nonce),
+      context.treeState
+    );
+    const treeState = mtpWithTreeState.treeState;
+    const revStatus: RevocationStatus = {
+      issuer: {
+        state: treeState?.state.string(),
+        claimsTreeRoot: treeState.claimsRoot.string(),
+        revocationTreeRoot: treeState.revocationRoot.string(),
+        rootOfRoots: treeState.rootOfRoots.string()
+      },
+      mtp: mtpWithTreeState.proof
+    };
+
+    const guid = uuid.v4();
+
+    const response: RevocationStatusResponseMessage = {
+      id: guid,
+      typ: MediaType.PlainMessage,
+      type: PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE,
+      thid: rsRequest.thid ?? guid,
+      body: revStatus,
+      from: context.senderDid.string(),
+      to: rsRequest.from
+    };
+
+    return response as BasicMessage;
+  }
+
+  /**
+   * @inheritdoc IRevocationStatusHandler#parseRevocationStatusRequest
+   */
+  async parseRevocationStatusRequest(request: Uint8Array): Promise<RevocationStatusRequestMessage> {
+    const { unpackedMessage: message } = await this._packerMgr.unpack(request);
+    const ciRequest = message as unknown as RevocationStatusRequestMessage;
+    if (message.type !== PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE) {
+      throw new Error('Invalid media type');
+    }
+    return ciRequest;
+  }
+
+  /**
+   * @inheritdoc IRevocationStatusHandler#handleRevocationStatusRequest
+   */
+  async handleRevocationStatusRequest(
+    did: DID,
+    request: Uint8Array,
+    opts?: RevocationStatusHandlerOptions
+  ): Promise<Uint8Array> {
+    if (!opts) {
+      opts = {
+        mediaType: MediaType.PlainMessage
+      };
+    }
+
+    if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
+      throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+    }
+
+    const rsRequest = await this.parseRevocationStatusRequest(request);
+    if (!opts.allowExpiredMessages) {
+      verifyExpiresTime(rsRequest);
+    }
+    const response = await this.handleRevocationStatusRequestMessage(rsRequest, {
+      senderDid: did,
+      mediaType: opts.mediaType,
+      packerOptions: opts.packerOptions,
+      treeState: opts.treeState
+    });
+
+    const packerOpts =
+      opts.mediaType === MediaType.SignedMessage
+        ? opts.packerOptions
+        : {
+            provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
+          };
+
+    if (!rsRequest.to) {
+      throw new Error(`failed request. empty 'to' field`);
+    }
+
+    const senderDID = DID.parse(rsRequest.to);
+    return this._packerMgr.pack(opts.mediaType, byteEncoder.encode(JSON.stringify(response)), {
+      senderDID,
+      ...packerOpts
+    });
+  }
+}

package/src/iden3comm/index.ts

@@ -0,0 +1,9 @@
+export * from './packageManager';
+export * from './packers';
+export * from './types';
+export * from './handlers';
+export * from './utils/did';
+export * from './utils/accept-profile';
+
+import * as PROTOCOL_CONSTANTS from './constants';
+export { PROTOCOL_CONSTANTS };

package/src/iden3comm/packageManager.ts

@@ -0,0 +1,143 @@
+import { BasicMessage, IPackageManager, IPacker, PackerParams } from './types';
+import { bytesToHeaderStub } from './utils/envelope';
+import { base64 } from 'rfc4648';
+import { MediaType } from './constants';
+import { byteDecoder, byteEncoder } from '../utils';
+
+/**
+ * Basic package manager for iden3 communication protocol
+ *
+ * @public
+ * @class PackageManager
+ * @implements implements IPackageManager interface
+ */
+export class PackageManager implements IPackageManager {
+  packers: Map<MediaType, IPacker>;
+
+  /**
+   * Creates an instance of PackageManager.
+   */
+  constructor() {
+    this.packers = new Map<MediaType, IPacker>();
+  }
+
+  /** {@inheritDoc IPackageManager.getSupportedProfiles} */
+  getSupportedProfiles(): string[] {
+    const acceptProfiles: string[] = [];
+    const mediaTypes = this.getSupportedMediaTypes();
+    for (const mediaType of mediaTypes) {
+      const p = this.packers.get(mediaType);
+      if (p) {
+        acceptProfiles.push(...p.getSupportedProfiles());
+      }
+    }
+    return [...new Set(acceptProfiles)];
+  }
+
+  /** {@inheritDoc IPackageManager.isProfileSupported} */
+  isProfileSupported(mediaType: MediaType, profile: string): boolean {
+    const p = this.packers.get(mediaType);
+    if (!p) {
+      return false;
+    }
+
+    return p.isProfileSupported(profile);
+  }
+
+  /** {@inheritDoc IPackageManager.getSupportedMediaTypes} */
+  getSupportedMediaTypes(): MediaType[] {
+    return [...this.packers.keys()];
+  }
+
+  /** {@inheritDoc IPackageManager.registerPackers} */
+  registerPackers(packers: Array<IPacker>): void {
+    packers.forEach((p) => {
+      this.packers.set(p.mediaType(), p);
+    });
+  }
+
+  /** {@inheritDoc IPackageManager.pack} */
+  async pack(mediaType: MediaType, payload: Uint8Array, params: PackerParams): Promise<Uint8Array> {
+    const p = this.packers.get(mediaType);
+    if (!p) {
+      throw new Error(`packer for media type ${mediaType} not found`);
+    }
+
+    return await p.pack(payload, params);
+  }
+
+  /**
+   * Packs a protocol message using the specified media type and packer parameters.
+   *
+   * @param mediaType - The media type to use for packing the message.
+   * @param protocolMessage - The protocol message to pack.
+   * @param params - The packer parameters.
+   * @returns A promise that resolves to the packed message as a Uint8Array.
+   * @throws An error if the packer for the specified media type is not found.
+   */
+  packMessage(
+    mediaType: MediaType,
+    protocolMessage: BasicMessage,
+    params: PackerParams
+  ): Promise<Uint8Array> {
+    const p = this.packers.get(mediaType);
+    if (!p) {
+      throw new Error(`packer for media type ${mediaType} not found`);
+    }
+
+    return p.packMessage(protocolMessage, params);
+  }
+
+  /** {@inheritDoc IPackageManager.unpack} */
+  async unpack(
+    envelope: Uint8Array
+  ): Promise<{ unpackedMessage: BasicMessage; unpackedMediaType: MediaType }> {
+    const decodedStr = byteDecoder.decode(envelope);
+    const safeEnvelope = decodedStr.trim();
+    const mediaType = this.getMediaType(safeEnvelope);
+    return {
+      unpackedMessage: await this.unpackWithSafeEnvelope(
+        mediaType,
+        byteEncoder.encode(safeEnvelope)
+      ),
+      unpackedMediaType: mediaType
+    };
+  }
+
+  /** {@inheritDoc IPackageManager.unpackWithType} */
+  async unpackWithType(mediaType: MediaType, envelope: Uint8Array): Promise<BasicMessage> {
+    const decoder = new TextDecoder('utf-8');
+    const decodedStr = decoder.decode(envelope);
+    const safeEnvelope = decodedStr.trim();
+    return await this.unpackWithSafeEnvelope(mediaType, byteEncoder.encode(safeEnvelope));
+  }
+
+  private async unpackWithSafeEnvelope(
+    mediaType: MediaType,
+    envelope: Uint8Array
+  ): Promise<BasicMessage> {
+    const p = this.packers.get(mediaType);
+    if (!p) {
+      throw new Error(`packer for media type ${mediaType} not found`);
+    }
+    const msg = await p.unpack(envelope);
+    return msg;
+  }
+
+  /** {@inheritDoc IPackageManager.getMediaType} */
+  getMediaType(envelope: string): MediaType {
+    let base64HeaderBytes: Uint8Array;
+
+    // full serialized
+    if (envelope[0] === '{') {
+      const envelopeStub = JSON.parse(envelope);
+      return envelopeStub.typ as MediaType;
+    } else {
+      const header = envelope.split('.')[0];
+      base64HeaderBytes = base64.parse(header, { loose: true });
+    }
+
+    const header = bytesToHeaderStub(base64HeaderBytes);
+    return header.typ;
+  }
+}

package/src/iden3comm/packers/index.ts

@@ -0,0 +1,3 @@
+export * from './zkp';
+export * from './plain';
+export * from './jws';