@mocanetwork/privado-js-sdk 1.0.0

package/src/iden3comm/types/packer.ts

@@ -0,0 +1,190 @@
+import { DID } from '@mocanetwork/moca-iden3';
+import { DataPrepareHandlerFunc, VerificationHandlerFunc } from '../packers';
+import { ProvingMethodAlg } from '@iden3/js-jwz';
+import { CircuitId } from '../../circuits';
+import { MediaType, PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { DIDDocument, VerificationMethod } from 'did-resolver';
+import { StateVerificationOpts } from './models';
+import { Attachment } from './protocol/attachment';
+
+/**
+ *  Protocol message type
+ */
+export type ProtocolMessage = (typeof PROTOCOL_MESSAGE_TYPE)[keyof typeof PROTOCOL_MESSAGE_TYPE];
+
+/**
+ * JSONValue
+ */
+export type JSONValue = string | number | boolean | object | Array<object>;
+
+/**
+ * JSON object
+ */
+export type JSONObject = {
+  [x: string]: JSONValue;
+};
+
+/**
+ * JSON document object
+ */
+export type JsonDocumentObject = { [key: string]: JsonDocumentObjectValue };
+
+/**
+ * JSON document object allowed values
+ */
+export type JsonDocumentObjectValue =
+  | string
+  | number
+  | boolean
+  | JsonDocumentObject
+  | JsonDocumentObjectValue[];
+
+/**
+ * Basic message with all possible fields optional
+ */
+export type BasicMessage = {
+  id: string;
+  typ?: MediaType;
+  type: ProtocolMessage;
+  thid?: string;
+  body?: unknown;
+  from?: string;
+  to?: string;
+  created_time?: number;
+  expires_time?: number;
+  attachments?: Attachment[];
+};
+
+/**
+ * Basic message with all possible fields required
+ */
+export type RequiredBasicMessage = Omit<
+  Required<BasicMessage>,
+  'created_time' | 'expires_time' | 'attachments'
+> & {
+  created_time?: number;
+  expires_time?: number;
+  attachments?: Attachment[];
+};
+
+/**
+ *  parameters for any packer
+ */
+export type PackerParams = {
+  [key in string]: any; //eslint-disable-line @typescript-eslint/no-explicit-any
+};
+/**
+ *  parameters for zkp packer
+ */
+export type ZKPPackerParams = PackerParams & {
+  senderDID: DID;
+  /** @deprecated */
+  profileNonce?: number | string;
+  provingMethodAlg: ProvingMethodAlg;
+};
+
+/**
+ *  SignerFn Is function to sign data with a verification method
+ *  @returns Promise of signature bytes;
+ */
+export type SignerFn = (vm: VerificationMethod, dataToSign: Uint8Array) => Promise<Uint8Array>;
+
+/**
+ *  JWSPackerParams are parameters for JWS packer
+ */
+export type JWSPackerParams = PackerParams & {
+  alg: string;
+  kid?: string;
+  didDocument?: DIDDocument;
+  signer?: SignerFn;
+};
+
+/**
+ *  parameters for plain packer
+ */
+export type PlainPackerParams = PackerParams;
+/**
+ *  signature of auth signals function preparer
+ */
+export type AuthDataPrepareFunc = (
+  hash: Uint8Array,
+  did: DID,
+  circuitId: CircuitId
+) => Promise<Uint8Array>;
+
+/**
+ *  signature of state function verifier
+ */
+export type StateVerificationFunc = (
+  id: string,
+  pubSignals: Array<string>,
+  opts?: StateVerificationOpts
+) => Promise<boolean>;
+
+/**
+ * Defines method that must be implemented by any packer
+ *
+ * @public
+ * @interface   IPacker
+ */
+export interface IPacker {
+  /**
+   * Packs the given payload and returns a promise that resolves to the packed data.
+   * @param payload - The payload to be packed.
+   * @param param - The packing parameters.
+   * @returns A promise that resolves to the packed data as a Uint8Array.
+   */
+  pack(payload: Uint8Array, param: PackerParams): Promise<Uint8Array>;
+
+  /**
+   * Packs the given message and returns a promise that resolves to the packed data.
+   * @param msg - The message to be packed.
+   * @param param - The packing parameters.
+   * @returns A promise that resolves to the packed data as a Uint8Array.
+   */
+  packMessage(msg: BasicMessage, param: PackerParams): Promise<Uint8Array>;
+
+  /**
+   * Unpacks the given envelope and returns a promise that resolves to the unpacked message.
+   * @param envelope - The envelope to be unpacked.
+   * @returns A promise that resolves to the unpacked message as a BasicMessage.
+   */
+  unpack(envelope: Uint8Array): Promise<BasicMessage>;
+
+  /**
+   * Returns the media type associated with the packer.
+   * @returns The media type as a MediaType.
+   */
+  mediaType(): MediaType;
+
+  /**
+   * gets packer envelope (supported profiles) with options
+   *
+   * @returns {string}
+   */
+  getSupportedProfiles(): string[];
+
+  /**
+   * returns true if profile is supported by packer
+   *
+   * @param {string} profile
+   * @returns {boolean}
+   */
+  isProfileSupported(profile: string): boolean;
+}
+/**
+ * Params for verification of auth circuit public signals
+ */
+export type VerificationParams = {
+  key: Uint8Array;
+  verificationFn: VerificationHandlerFunc;
+};
+
+/**
+ * Params for generation of proof for auth circuit
+ */
+export type ProvingParams = {
+  dataPreparer: DataPrepareHandlerFunc;
+  provingKey: Uint8Array;
+  wasm: Uint8Array;
+};

package/src/iden3comm/types/protocol/accept-profile.ts

@@ -0,0 +1,14 @@
+import {
+  AcceptAuthCircuits,
+  AcceptJwsAlgorithms,
+  AcceptJwzAlgorithms,
+  MediaType,
+  ProtocolVersion
+} from '../../constants';
+
+export type AcceptProfile = {
+  protocolVersion: ProtocolVersion;
+  env: MediaType;
+  circuits?: AcceptAuthCircuits[];
+  alg?: AcceptJwsAlgorithms[] | AcceptJwzAlgorithms[];
+};

package/src/iden3comm/types/protocol/attachment.ts

@@ -0,0 +1,12 @@
+import { JsonDocumentObject } from '../packer';
+
+export type Attachment = {
+  id: string;
+  description?: string;
+  media_type?: string;
+  data: AttachData;
+};
+
+export type AttachData = {
+  json: JsonDocumentObject;
+};

package/src/iden3comm/types/protocol/auth.ts

@@ -0,0 +1,104 @@
+import { ZKProof } from '@iden3/js-jwz';
+import { BasicMessage, JsonDocumentObject } from '../packer';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { ProofType } from '../../../verifiable';
+import { CircuitId } from '../../../circuits';
+import {
+  DIDDocument as DidResolverDidDocument,
+  VerificationMethod as DidResolverVerificationMethod
+} from 'did-resolver';
+import { RootInfo, StateInfo } from '../../../storage';
+import { AuthProof, CrossChainProof } from './contract-request';
+
+/** AuthorizationResponseMessage is struct the represents iden3message authorization response */
+export type AuthorizationResponseMessage = BasicMessage & {
+  body: AuthorizationMessageResponseBody;
+  from: string;
+  to: string;
+  type: typeof PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE;
+};
+
+/** AuthorizationMessageResponseBody is struct the represents authorization response data */
+export type AuthorizationMessageResponseBody = {
+  did_doc?: DIDDocument;
+  message?: string;
+  scope: Array<ZeroKnowledgeProofResponse>;
+};
+
+/** AuthorizationRequestMessage is struct the represents iden3message authorization request */
+export type AuthorizationRequestMessage = BasicMessage & {
+  body: AuthorizationRequestMessageBody;
+  from: string;
+  type: typeof PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE;
+};
+
+/** AuthorizationRequestMessageBody is body for authorization request */
+export type AuthorizationRequestMessageBody = {
+  callbackUrl: string;
+  reason?: string;
+  message?: string;
+  did_doc?: DIDDocument;
+  scope: Array<ZeroKnowledgeProofRequest>;
+  accept?: string[];
+};
+
+/** ZeroKnowledgeProofRequest represents structure of zkp request object */
+export type ZeroKnowledgeProofRequest = {
+  id: number | string;
+  circuitId: CircuitId;
+  optional?: boolean;
+  query: ZeroKnowledgeProofQuery;
+  params?: {
+    nullifierSessionId?: string | number;
+  };
+};
+
+/** ZeroKnowledgeProofQuery represents structure of zkp request query object */
+export type ZeroKnowledgeProofQuery = {
+  allowedIssuers: string[];
+  context: string;
+  credentialSubject?: JsonDocumentObject;
+  proofType?: ProofType;
+  skipClaimRevocationCheck?: boolean;
+  groupId?: number;
+  type: string;
+};
+
+export type ZeroKnowledgeInvokeResponse = {
+  responses: ZeroKnowledgeProofResponse[];
+  crossChainProof?: CrossChainProof;
+  authProof?: AuthProof;
+};
+
+/** ZeroKnowledgeProofResponse represents structure of zkp response */
+export type ZeroKnowledgeProofResponse = {
+  id: number | string;
+  circuitId: string;
+  vp?: VerifiablePresentation;
+} & ZKProof;
+
+/** ZeroKnowledgeProofAuthResponse represents structure of zkp auth response */
+export type ZeroKnowledgeProofAuthResponse = Omit<ZeroKnowledgeProofResponse, 'id' | 'vp'>;
+
+/** VerifiablePresentation represents structure of Verifiable Presentation */
+export type VerifiablePresentation = {
+  '@context': string | (string | object)[];
+  type: string;
+  verifiableCredential: {
+    '@context': string | string[];
+    type: string | string[];
+    credentialSubject: JsonDocumentObject;
+  };
+};
+
+/** DIDDocument represents structure of DID Document */
+export type DIDDocument = DidResolverDidDocument & {
+  verificationMethod?: VerificationMethod[];
+};
+
+/** VerificationMethod represents structure of Verification Method */
+export type VerificationMethod = DidResolverVerificationMethod & {
+  published?: boolean;
+  info?: StateInfo;
+  global?: RootInfo;
+};

package/src/iden3comm/types/protocol/common.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents information about a credential schema.
+ *
+ * @property {string} type - The type of the credential schema.
+ * @property {string} context - The context in which the credential schema is used.
+ */
+export type CredentialSchemaInfo = {
+  type: string;
+  context: string;
+};

package/src/iden3comm/types/protocol/contract-request.ts

@@ -0,0 +1,76 @@
+import { GlobalStateUpdate, IdentityStateUpdate } from '../../../storage/entities/state';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { BasicMessage } from '../packer';
+import {
+  DIDDocument,
+  ZeroKnowledgeProofAuthResponse,
+  ZeroKnowledgeProofRequest,
+  ZeroKnowledgeProofResponse
+} from './auth';
+import { DID } from '@mocanetwork/moca-iden3';
+
+/** ContractInvokeRequest represents structure of contract invoke request object */
+export type ContractInvokeRequest = BasicMessage & {
+  body: ContractInvokeRequestBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE;
+};
+
+/** ContractInvokeRequestBody represents structure of contract invoke request body object */
+export type ContractInvokeRequestBody = {
+  reason?: string;
+  transaction_data: ContractInvokeTransactionData;
+  scope: Array<ZeroKnowledgeProofRequest>;
+  did_doc?: DIDDocument;
+  accept?: string[];
+};
+
+/** ContractInvokeResponse represents structure of contract invoke response object */
+export type ContractInvokeResponse = BasicMessage & {
+  body: ContractInvokeResponseBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE;
+};
+
+/** ContractInvokeResponseBody represents structure of contract invoke response body object */
+export type ContractInvokeResponseBody = {
+  scope: Array<OnChainZeroKnowledgeProofResponse>;
+  transaction_data: ContractInvokeTransactionData;
+  did_doc?: DIDDocument;
+  crossChainProof?: CrossChainProof;
+  authProof?: AuthProof;
+};
+
+/** OnChainZeroKnowledgeProofResponse represents structure of onchain zero knowledge proof response */
+export type OnChainZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse & {
+  txHash?: string;
+};
+
+/** ContractInvokeTransactionData represents structure of contract invoke transaction data object */
+export type ContractInvokeTransactionData = {
+  contract_address: string;
+  method_id: string;
+  chain_id: number;
+  network?: string;
+  txHash?: string;
+};
+
+export type AuthProofEthIdentity = {
+  userDid: DID;
+};
+export type AuthProofZKP = {
+  zkp: ZeroKnowledgeProofAuthResponse;
+};
+
+/** AuthProofResponse represents structure of zkp response */
+export type AuthProof = {
+  authMethod: AuthMethod;
+} & (AuthProofEthIdentity | AuthProofZKP);
+
+export type CrossChainProof = {
+  globalStateProofs: GlobalStateUpdate[];
+  identityStateProofs: IdentityStateUpdate[];
+};
+
+export enum AuthMethod {
+  AUTHV2 = 'authV2',
+  ETH_IDENTITY = 'ethIdentity'
+}

package/src/iden3comm/types/protocol/credentials.ts

@@ -0,0 +1,96 @@
+import { W3CCredential } from '../../../verifiable';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { BasicMessage, JsonDocumentObject, RequiredBasicMessage } from '../packer';
+import { ContractInvokeTransactionData } from './contract-request';
+
+/** CredentialIssuanceRequestMessageBody represents data for credential issuance request */
+export type CredentialIssuanceRequestMessageBody = {
+  schema: Schema;
+  data: JsonDocumentObject;
+  expiration: number;
+};
+
+/** CredentialIssuanceRequestMessage represent Iden3message for credential request */
+export type CredentialIssuanceRequestMessage = RequiredBasicMessage & {
+  body: CredentialIssuanceRequestMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_REQUEST_MESSAGE_TYPE;
+};
+
+/** CredentialsOfferMessage represent Iden3message for credential offer */
+export type CredentialsOfferMessage = RequiredBasicMessage & {
+  body: CredentialsOfferMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE;
+};
+
+/** CredentialsOfferMessageBody is struct the represents offer message */
+export type CredentialsOfferMessageBody = {
+  url: string;
+  credentials: CredentialOffer[];
+};
+
+/** CredentialsOnchainOfferMessage represent Iden3message for credential onchain offer message */
+export type CredentialsOnchainOfferMessage = RequiredBasicMessage & {
+  body: CredentialsOnchainOfferMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE;
+};
+
+/** CredentialsOnchainOfferMessageBody is struct the represents onchain offer message body */
+export type CredentialsOnchainOfferMessageBody = {
+  credentials: CredentialOffer[];
+  transaction_data: ContractInvokeTransactionData;
+};
+
+/** CredentialOfferStatus is list of possible statuses for credential offer message */
+export enum CredentialOfferStatus {
+  Pending = 'pending',
+  Completed = 'completed',
+  Rejected = 'rejected'
+}
+
+/** CredentialOffer is structure to fetch credential */
+export type CredentialOffer = {
+  id: string;
+  description: string;
+  status?: CredentialOfferStatus;
+};
+
+/** CredentialIssuanceMessage represent Iden3message for credential issuance */
+export type CredentialIssuanceMessage = RequiredBasicMessage & {
+  body: IssuanceMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE;
+};
+
+/** IssuanceMessageBody is struct the represents message when credential is issued */
+export type IssuanceMessageBody = {
+  credential: W3CCredential;
+};
+
+/** CredentialFetchRequestMessage represent Iden3message for credential fetch request */
+export type CredentialFetchRequestMessage = BasicMessage & {
+  body: CredentialFetchRequestMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE;
+};
+
+/** CredentialFetchRequestMessageBody is msg body for fetch request */
+export type CredentialFetchRequestMessageBody = {
+  id: string;
+};
+
+/** Schema represents location and type where it's stored */
+export type Schema = {
+  hash?: string;
+  url: string;
+  type: string;
+};
+
+/** CredentialRefreshMessage represent Iden3message for credential refresh request */
+export type CredentialRefreshMessage = RequiredBasicMessage & {
+  body: CredentialRefreshMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_REFRESH_MESSAGE_TYPE;
+};
+
+/** CredentialRefreshMessageBody is msg body for refresh request */
+export type CredentialRefreshMessageBody = {
+  id: string;
+  reason: string;
+};

package/src/iden3comm/types/protocol/discovery-protocol.ts

@@ -0,0 +1,49 @@
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { BasicMessage } from '../packer';
+
+/** @beta DiscoverFeatureQueryType is enum for query type fields */
+export enum DiscoverFeatureQueryType {
+  FeatureType = 'feature-type'
+}
+
+/** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
+export enum DiscoveryProtocolFeatureType {
+  Accept = 'accept',
+  Protocol = 'protocol',
+  GoalCode = 'goal-code',
+  Header = 'header'
+}
+
+/** @beta DiscoverFeatureQueriesMessage is struct the represents discover feature queries message */
+export type DiscoverFeatureQueriesMessage = BasicMessage & {
+  body: DiscoverFeatureQueriesBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE;
+};
+
+/** @beta DiscoverFeatureQueriesBody is struct the represents discover feature queries body */
+export type DiscoverFeatureQueriesBody = {
+  queries: DiscoverFeatureQuery[];
+};
+
+/** @beta DiscoverFeatureQuery is struct the represents discover feature query */
+export type DiscoverFeatureQuery = {
+  [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
+  match?: string;
+};
+
+/** @beta DiscoverFeatureDiscloseMessage is struct the represents discover feature disclose message */
+export type DiscoverFeatureDiscloseMessage = BasicMessage & {
+  body: DiscoverFeatureDiscloseBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE;
+};
+
+/** @beta DiscoverFeatureDiscloseBody is struct the represents discover feature disclose body */
+export type DiscoverFeatureDiscloseBody = {
+  disclosures: DiscoverFeatureDisclosure[];
+};
+
+/** @beta DiscoverFeatureDisclosure is struct the represents discover feature disclosure */
+export type DiscoverFeatureDisclosure = {
+  [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
+  id: string;
+};

package/src/iden3comm/types/protocol/messages.ts

@@ -0,0 +1,13 @@
+import { RequiredBasicMessage } from '../';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+
+/**  MessageFetchRequestMessage represent Iden3message for message fetch request. */
+export type MessageFetchRequestMessage = RequiredBasicMessage & {
+  body: MessageFetchRequestMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE;
+};
+
+/** MessageFetchRequestMessageBody is struct the represents body for message fetch request. */
+export type MessageFetchRequestMessageBody = {
+  id: string;
+};