@mocanetwork/privado-js-sdk 1.0.0

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

@@ -0,0 +1,231 @@
+import { BasicMessage } from '../';
+import {
+  PaymentFeatures,
+  PaymentRequestDataType,
+  SupportedCurrencies,
+  SupportedPaymentProofType
+} from '../../../verifiable';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { CredentialSchemaInfo } from './common';
+
+/** @beta PaymentRequestMessage is struct the represents payment-request message */
+export type PaymentRequestMessage = BasicMessage & {
+  body: PaymentRequestMessageBody;
+  from: string;
+  to: string;
+  type: typeof PROTOCOL_MESSAGE_TYPE.PAYMENT_REQUEST_MESSAGE_TYPE;
+};
+
+/** @beta PaymentRequestMessageBody is struct the represents body for payment-request */
+export type PaymentRequestMessageBody = {
+  agent: string;
+  payments: PaymentRequestInfo[];
+};
+
+/** @beta PaymentRequestInfo is struct the represents payment info for payment-request */
+export type PaymentRequestInfo = {
+  credentials: CredentialSchemaInfo[];
+  data:
+    | Iden3PaymentRequestCryptoV1
+    | (
+        | Iden3PaymentRequestCryptoV1
+        | Iden3PaymentRailsRequestV1
+        | Iden3PaymentRailsERC20RequestV1
+        | Iden3PaymentRailsSolanaRequestV1
+        | Iden3PaymentRailsSolanaSPLRequestV1
+      )[];
+  description?: string;
+};
+
+/** @beta Iden3PaymentRequestCryptoV1 is struct the represents payment data info for payment-request */
+export type Iden3PaymentRequestCryptoV1 = {
+  type: PaymentRequestDataType.Iden3PaymentRequestCryptoV1;
+  '@context'?: string | (string | object)[];
+  amount: string;
+  id: string;
+  chainId: string;
+  address: string;
+  currency: SupportedCurrencies | string;
+  expiration?: string;
+};
+
+/** @beta Iden3PaymentRailsRequestV1 is struct the represents EVM native payment rails request */
+export type Iden3PaymentRailsRequestV1 = {
+  type: PaymentRequestDataType.Iden3PaymentRailsRequestV1;
+  '@context': string | (string | object)[];
+  recipient: string;
+  amount: string;
+  expirationDate: string;
+  nonce: string;
+  metadata: string;
+  proof: EthereumEip712Signature2021 | EthereumEip712Signature2021[];
+};
+
+/** @beta Iden3PaymentRailsERC20RequestV1 is struct the represents EVM ERC 20 payment rails request */
+export type Iden3PaymentRailsERC20RequestV1 = Omit<Required<Iden3PaymentRailsRequestV1>, 'type'> & {
+  tokenAddress: string;
+  features?: PaymentFeatures[];
+  type: PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1;
+};
+
+/** @beta Iden3PaymentRailsSolanaRequestV1 is struct the represents Solana native payment rails request */
+export type Iden3PaymentRailsSolanaRequestV1 = Omit<
+  Required<Iden3PaymentRailsRequestV1>,
+  'type' | 'proof'
+> & {
+  type: PaymentRequestDataType.Iden3PaymentRailsSolanaRequestV1;
+  proof: Iden3SolanaEd25519SignatureV1 | Iden3SolanaEd25519SignatureV1[];
+};
+
+/** @beta Iden3PaymentRailsSolanaSPLRequestV1 is struct the represents Solana SPL payment rails request */
+export type Iden3PaymentRailsSolanaSPLRequestV1 = Omit<
+  Required<Iden3PaymentRailsERC20RequestV1>,
+  'type' | 'proof'
+> & {
+  type: PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1;
+  proof: Iden3SolanaEd25519SignatureV1 | Iden3SolanaEd25519SignatureV1[];
+};
+
+/** @beta EthereumEip712Signature2021 is struct the represents EIP-712 signature for Ethereum */
+export type EthereumEip712Signature2021 = {
+  type: SupportedPaymentProofType.EthereumEip712Signature2021;
+  proofPurpose: string;
+  proofValue: string;
+  verificationMethod: string;
+  created: string;
+  eip712: {
+    types: string;
+    primaryType: string;
+    domain: {
+      name: string;
+      version: string;
+      chainId: string;
+      verifyingContract: string;
+    };
+  };
+};
+
+/** @beta Iden3SolanaEd25519SignatureV1 is struct the represents Ed25519 signature for Solana Payment Instruction */
+export type Iden3SolanaEd25519SignatureV1 = {
+  type: SupportedPaymentProofType.SolanaEd25519Signature2025;
+  proofPurpose: string;
+  proofValue: string;
+  created: string;
+  verificationMethod: string;
+  domain: {
+    version: 'SolanaEd25519NativeV1' | 'SolanaEd25519SPLV1';
+    chainId: string;
+    verifyingContract: string;
+  };
+};
+
+/** @beta  PaymentMessage is struct the represents payment message */
+export type PaymentMessage = BasicMessage & {
+  body: PaymentMessageBody;
+  from: string;
+  to: string;
+  type: typeof PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE;
+};
+
+/** @beta  PaymentMessageBody is struct the represents body for payment message */
+export type PaymentMessageBody = {
+  payments: PaymentTypeUnion[];
+};
+
+/** @beta Iden3PaymentCryptoV1 is struct the represents payment info for payment */
+export type Iden3PaymentCryptoV1 = {
+  id: string;
+  type: 'Iden3PaymentCryptoV1';
+  '@context'?: string | (string | object)[];
+  paymentData: {
+    txId: string;
+  };
+};
+
+/** @beta Iden3PaymentRailsV1 is struct the represents payment info for Iden3PaymentRailsRequestV1 */
+export type Iden3PaymentRailsV1 = {
+  nonce: string;
+  type: 'Iden3PaymentRailsV1';
+  '@context': string | (string | object)[];
+  paymentData: {
+    txId: string;
+    chainId: string;
+  };
+};
+
+/** @beta Iden3PaymentRailsERC20V1 is struct the represents payment info for Iden3PaymentRailsERC20RequestV1 */
+export type Iden3PaymentRailsERC20V1 = {
+  nonce: string;
+  type: 'Iden3PaymentRailsERC20V1';
+  '@context': string | (string | object)[];
+  paymentData: {
+    txId: string;
+    chainId: string;
+    tokenAddress: string;
+  };
+};
+
+/** @beta Iden3PaymentRailsSolanaV1 is struct the represents payment info for Iden3PaymentRailsSolanaV1 */
+export type Iden3PaymentRailsSolanaV1 = {
+  nonce: string;
+  type: 'Iden3PaymentRailsSolanaV1';
+  '@context': string | (string | object)[];
+  paymentData: {
+    txId: string;
+    chainId: string;
+  };
+};
+
+/** @beta Iden3PaymentRailsSolanaSPLV1 is struct the represents payment info for Iden3PaymentRailsSolanaSPLV1 */
+export type Iden3PaymentRailsSolanaSPLV1 = {
+  nonce: string;
+  type: 'Iden3PaymentRailsSolanaSPLV1';
+  '@context': string | (string | object)[];
+  paymentData: {
+    txId: string;
+    chainId: string;
+    tokenAddress: string;
+  };
+};
+
+/** @beta MultiChainPaymentConfig is struct that represents payments contracts information for different chains */
+export type MultiChainPaymentConfig = {
+  chainId: string;
+  paymentRails: string;
+  recipient: string;
+  options: MultiChainPaymentConfigOption[];
+};
+
+/** @beta MultiChainPaymentConfigOption is struct that represents payment options for different chains */
+export type MultiChainPaymentConfigOption = {
+  id: string;
+  type:
+    | PaymentRequestDataType.Iden3PaymentRailsRequestV1
+    | PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1
+    | PaymentRequestDataType.Iden3PaymentRailsSolanaRequestV1
+    | PaymentRequestDataType.Iden3PaymentRailsSolanaSPLRequestV1;
+  contractAddress?: string;
+  features?: PaymentFeatures[];
+};
+
+/**
+ * @beta
+ * PaymentRequestTypeUnion is a type of supported payment request types
+ */
+export type PaymentRequestTypeUnion =
+  | Iden3PaymentRequestCryptoV1
+  | Iden3PaymentRailsRequestV1
+  | Iden3PaymentRailsERC20RequestV1
+  | Iden3PaymentRailsSolanaRequestV1
+  | Iden3PaymentRailsSolanaSPLRequestV1;
+
+/**
+ * @beta
+ * PaymentTypeUnion is a type of supported payment types
+ */
+export type PaymentTypeUnion =
+  | Iden3PaymentCryptoV1
+  | Iden3PaymentRailsV1
+  | Iden3PaymentRailsERC20V1
+  | Iden3PaymentRailsSolanaV1
+  | Iden3PaymentRailsSolanaSPLV1;

package/src/iden3comm/types/protocol/problem-report.ts

@@ -0,0 +1,18 @@
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { BasicMessage } from '../packer';
+
+/** ProblemReportMessage is struct for problem report message */
+export type ProblemReportMessage = BasicMessage & {
+  body: ProblemReportMessageBody;
+  pthid: string;
+  ack?: string[];
+  type: typeof PROTOCOL_MESSAGE_TYPE.PROBLEM_REPORT_MESSAGE_TYPE;
+};
+
+/** ProblemReportMessageBody is struct for problem report message body */
+export type ProblemReportMessageBody = {
+  code: string;
+  comment?: string;
+  args?: string[];
+  escalate_to?: string;
+};

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

@@ -0,0 +1,25 @@
+import { RequiredBasicMessage } from '../';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
+
+/** ProofGenerationRequestMessage is struct the represents body for proof generation request */
+export type ProofGenerationRequestMessage = RequiredBasicMessage & {
+  body: ProofGenerationRequestMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.PROOF_GENERATION_REQUEST_MESSAGE_TYPE;
+};
+
+/** ProofGenerationRequestMessageBody is struct the represents body for proof generation request */
+export type ProofGenerationRequestMessageBody = {
+  scope: Array<ZeroKnowledgeProofRequest>;
+};
+
+/** ProofGenerationResponseMessage is struct the represents body for proof generation request */
+export type ProofGenerationResponseMessage = RequiredBasicMessage & {
+  body: ResponseMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.PROOF_GENERATION_RESPONSE_MESSAGE_TYPE;
+};
+
+/** ResponseMessageBody is struct the represents request for revocation status */
+export type ResponseMessageBody = {
+  scope: Array<ZeroKnowledgeProofResponse>;
+};

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

@@ -0,0 +1,38 @@
+import { BasicMessage, DIDDocument } from '../';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { CredentialSchemaInfo } from './common';
+
+/** @beta ProposalRequestMessage is struct the represents proposal-request message */
+export type ProposalRequestMessage = BasicMessage & {
+  body: ProposalRequestMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE;
+};
+
+/** @beta  ProposalRequestCredential is struct the represents proposal request credential */
+export type ProposalRequestCredential = CredentialSchemaInfo;
+
+/** @beta ProposalRequestMessageBody is struct the represents body for proposal-request */
+export type ProposalRequestMessageBody = {
+  credentials: ProposalRequestCredential[];
+  did_doc?: DIDDocument;
+};
+
+/** @beta  ProposalMessage is struct the represents proposal message */
+export type ProposalMessage = BasicMessage & {
+  body: ProposalMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.PROPOSAL_MESSAGE_TYPE;
+};
+
+/** @beta  ProposalMessageBody is struct the represents body for proposal message */
+export type ProposalMessageBody = {
+  proposals: Proposal[];
+};
+
+/** @beta Proposal is struct the represents proposal inside proposal protocol message */
+export type Proposal = {
+  credentials: ProposalRequestCredential[];
+  type: string;
+  url?: string;
+  expiration?: string;
+  description?: string;
+};

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

@@ -0,0 +1,23 @@
+import { BasicMessage, RequiredBasicMessage } from '../';
+import { RevocationStatus } from '../../../verifiable';
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+
+/** RevocationStatusRequestMessage is struct the represents body for proof generation request */
+export type RevocationStatusRequestMessage = BasicMessage & {
+  body: RevocationStatusRequestMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE;
+};
+
+/** RevocationStatusRequestMessageBody is struct the represents request for revocation status */
+export type RevocationStatusRequestMessageBody = {
+  revocation_nonce: number;
+};
+
+/** RevocationStatusResponseMessage is struct the represents body for proof generation request */
+export type RevocationStatusResponseMessage = RequiredBasicMessage & {
+  body: RevocationStatusResponseMessageBody;
+  type: typeof PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE;
+};
+
+/** RevocationStatusResponseMessageBody is struct the represents request for revocation status */
+export type RevocationStatusResponseMessageBody = RevocationStatus;

package/src/iden3comm/utils/accept-profile.ts

@@ -0,0 +1,121 @@
+import {
+  MediaType,
+  ProtocolVersion,
+  AcceptAuthCircuits,
+  AcceptJwzAlgorithms,
+  AcceptJwsAlgorithms
+} from '../constants';
+import { AcceptProfile } from '../types';
+
+function isProtocolVersion(value: string): boolean {
+  return Object.values(ProtocolVersion).includes(value as ProtocolVersion);
+}
+
+function isMediaType(value: string): boolean {
+  return Object.values(MediaType).includes(value as MediaType);
+}
+
+function isAcceptAuthCircuits(value: string): boolean {
+  return Object.values(AcceptAuthCircuits).includes(value as AcceptAuthCircuits);
+}
+
+function isAcceptJwsAlgorithms(value: string): boolean {
+  return Object.values(AcceptJwsAlgorithms).includes(value as AcceptJwsAlgorithms);
+}
+
+function isAcceptJwzAlgorithms(value: string): boolean {
+  return Object.values(AcceptJwzAlgorithms).includes(value as AcceptJwzAlgorithms);
+}
+
+export const buildAccept = (profiles: AcceptProfile[]): string[] => {
+  const result = [];
+  for (const profile of profiles) {
+    let accept = `${profile.protocolVersion};env=${profile.env}`;
+    if (profile.circuits?.length) {
+      accept += `;circuitId=${profile.circuits.join(',')}`;
+    }
+    if (profile.alg?.length) {
+      accept += `;alg=${profile.alg.join(',')}`;
+    }
+    result.push(accept);
+  }
+
+  return result;
+};
+
+export const parseAcceptProfile = (profile: string): AcceptProfile => {
+  const params = profile.split(';');
+
+  if (params.length < 2) {
+    throw new Error('Invalid accept profile');
+  }
+  const protocolVersion = params[0].trim() as ProtocolVersion;
+  if (!isProtocolVersion(protocolVersion)) {
+    throw new Error(`Protocol version '${protocolVersion}' not supported`);
+  }
+
+  const envParam = params[1].split('=');
+  if (envParam.length !== 2) {
+    throw new Error(`Invalid accept profile 'env' parameter`);
+  }
+  const env = params[1].split('=')[1].trim() as MediaType;
+  if (!isMediaType(env)) {
+    throw new Error(`Envelop '${env}' not supported`);
+  }
+
+  const circuitsIndex = params.findIndex((i: string) => i.includes('circuitId='));
+  if (env !== MediaType.ZKPMessage && circuitsIndex > 0) {
+    throw new Error(`Circuits not supported for env '${env}'`);
+  }
+
+  let circuits: AcceptAuthCircuits[] | undefined = undefined;
+  if (circuitsIndex > 0) {
+    circuits = params[circuitsIndex]
+      .split('=')[1]
+      .split(',')
+      .map((i) => i.trim())
+      .map((i) => {
+        if (!isAcceptAuthCircuits(i)) {
+          throw new Error(`Circuit '${i}' not supported`);
+        }
+        return i as AcceptAuthCircuits;
+      });
+  }
+
+  const algIndex = params.findIndex((i: string) => i.includes('alg='));
+  let alg: AcceptJwsAlgorithms[] | AcceptJwzAlgorithms[] | undefined = undefined;
+  if (algIndex > 0) {
+    if (env === MediaType.ZKPMessage) {
+      alg = params[algIndex]
+        .split('=')[1]
+        .split(',')
+        .map((i) => {
+          i = i.trim();
+          if (!isAcceptJwzAlgorithms(i)) {
+            throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+          }
+          return i as AcceptJwzAlgorithms;
+        });
+    } else if (env === MediaType.SignedMessage) {
+      alg = params[algIndex]
+        .split('=')[1]
+        .split(',')
+        .map((i) => {
+          i = i.trim();
+          if (!isAcceptJwsAlgorithms(i)) {
+            throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+          }
+          return i as AcceptJwsAlgorithms;
+        });
+    } else {
+      throw new Error(`Algorithm not supported for '${env}'`);
+    }
+  }
+
+  return {
+    protocolVersion,
+    env,
+    circuits,
+    alg
+  };
+};

package/src/iden3comm/utils/did.ts

@@ -0,0 +1,71 @@
+import { SUPPORTED_PUBLIC_KEY_TYPES } from '../constants';
+import { DIDDocument, VerificationMethod } from 'did-resolver';
+import { secp256k1 as sec } from '@noble/curves/secp256k1';
+
+import { KmsKeyType } from '../../kms';
+import { base58ToBytes, base64UrlToBytes, bytesToHex, hexToBytes } from '../../utils';
+
+const DIDAuthenticationSection = 'authentication';
+export const resolveVerificationMethods = (didDocument: DIDDocument): VerificationMethod[] => {
+  const vms: VerificationMethod[] = didDocument.verificationMethod || [];
+
+  // prioritize: first verification methods to be chosen are from `authentication` section.
+  const sortedVerificationMethods = (didDocument[DIDAuthenticationSection] || [])
+    .map((verificationMethod) => {
+      if (typeof verificationMethod === 'string') {
+        return vms.find((i) => i.id === verificationMethod);
+      }
+      return verificationMethod as VerificationMethod;
+    })
+    .filter((key) => key) as VerificationMethod[];
+
+  // add all other verification methods
+  for (let index = 0; index < vms.length; index++) {
+    const id = vms[index].id;
+    if (sortedVerificationMethods.findIndex((vm) => vm.id === id) === -1) {
+      sortedVerificationMethods.push(vms[index]);
+    }
+  }
+  return sortedVerificationMethods;
+};
+
+export const extractPublicKeyBytes = (
+  vm: VerificationMethod
+): { publicKeyBytes: Uint8Array | null; kmsKeyType?: KmsKeyType } => {
+  const isSupportedVmType = Object.keys(SUPPORTED_PUBLIC_KEY_TYPES).some((key) =>
+    SUPPORTED_PUBLIC_KEY_TYPES[key as keyof typeof SUPPORTED_PUBLIC_KEY_TYPES].includes(vm.type)
+  );
+  if (vm.publicKeyBase58 && isSupportedVmType) {
+    return { publicKeyBytes: base58ToBytes(vm.publicKeyBase58), kmsKeyType: KmsKeyType.Secp256k1 };
+  }
+  if (vm.publicKeyBase64 && isSupportedVmType) {
+    return {
+      publicKeyBytes: base64UrlToBytes(vm.publicKeyBase64),
+      kmsKeyType: KmsKeyType.Secp256k1
+    };
+  }
+  if (vm.publicKeyHex && isSupportedVmType) {
+    return { publicKeyBytes: hexToBytes(vm.publicKeyHex), kmsKeyType: KmsKeyType.Secp256k1 };
+  }
+  if (
+    vm.publicKeyJwk &&
+    vm.publicKeyJwk.crv === 'secp256k1' &&
+    vm.publicKeyJwk.x &&
+    vm.publicKeyJwk.y
+  ) {
+    const [xHex, yHex] = [
+      base64UrlToBytes(vm.publicKeyJwk.x),
+      base64UrlToBytes(vm.publicKeyJwk.y)
+    ].map(bytesToHex);
+    const x = xHex.includes('0x') ? BigInt(xHex) : BigInt(`0x${xHex}`);
+    const y = yHex.includes('0x') ? BigInt(yHex) : BigInt(`0x${yHex}`);
+    return {
+      publicKeyBytes: sec.ProjectivePoint.fromAffine({
+        x,
+        y
+      }).toRawBytes(false),
+      kmsKeyType: KmsKeyType.Secp256k1
+    };
+  }
+  return { publicKeyBytes: null };
+};

package/src/iden3comm/utils/envelope.ts

@@ -0,0 +1,101 @@
+import { BasicMessage, EnvelopeStub, HeaderStub } from '../types';
+import { basicMessageFactory, envelopeStubFactory, headerStubFactory } from './message';
+import { ErrNotEnvelopeStub, ErrNotHeaderStub, ErrNotProtocolMessage } from '../errors';
+import { Token } from '@iden3/js-jwz';
+import { byteDecoder, byteEncoder } from '../../utils';
+
+const objectIs = (
+  obj: { [key in string]: any }, //eslint-disable-line @typescript-eslint/no-explicit-any
+  targetObj: { [key in string]: any } //eslint-disable-line @typescript-eslint/no-explicit-any
+): boolean => {
+  Object.keys(targetObj).forEach((prop) => {
+    if (!obj[prop]) {
+      return false;
+    }
+    if (typeof targetObj[prop as keyof typeof targetObj] !== typeof obj[prop as keyof typeof obj]) {
+      return false;
+    }
+  });
+  return true;
+};
+
+//eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isProtocolMessage = (message: { [key in string]: any }): boolean => {
+  const basicMessage = basicMessageFactory();
+  Object.keys(basicMessage).forEach((prop) => {
+    if (!message[prop]) {
+      return false;
+    }
+    if (prop !== 'body') {
+      const res =
+        typeof basicMessage[prop as keyof typeof basicMessage] ===
+        typeof (message[prop as keyof typeof message] as any); //eslint-disable-line @typescript-eslint/no-explicit-any
+      if (!res) {
+        return false;
+      }
+    }
+  });
+
+  return true;
+};
+
+/**
+ *
+ * @param {Uint8Array} e
+ * @returns Promise<BasicMessage>
+ */
+export const envelopeToProtocolMessage = async (e: Uint8Array): Promise<BasicMessage> => {
+  const t = await Token.parse(byteDecoder.decode(e));
+  const pBytes = byteEncoder.encode(t.getPayload());
+  return bytesToProtocolMessage(pBytes);
+};
+
+/**
+ * helper function to convert serialized JSON bytes to protocol message
+ *
+ * @param {Uint8Array} bytes
+ * @returns  {BasicMessage}
+ */
+export const bytesToProtocolMessage = (bytes: Uint8Array): BasicMessage => {
+  const str = byteDecoder.decode(bytes);
+  const message = JSON.parse(str);
+  if (!isProtocolMessage(message)) {
+    throw new Error(ErrNotProtocolMessage);
+  }
+  return message as BasicMessage;
+};
+
+/**
+ * helper function to convert serialized JSON bytes to envelop stub
+ * so we can work with protected field of jwt token
+ *
+ *
+ * @param {Uint8Array} envelope
+ * @returns {EnvelopeStub}
+ */
+export const bytesToEnvelopeStub = (envelope: Uint8Array): EnvelopeStub => {
+  const tmpObj = envelopeStubFactory();
+  const str = byteDecoder.decode(envelope);
+  const message = JSON.parse(str);
+  if (!objectIs(message, tmpObj)) {
+    throw new Error(ErrNotEnvelopeStub);
+  }
+  return message as EnvelopeStub;
+};
+
+/**
+ * helper function to convert serialized JSON bytes to header stub
+ * so we can work with know the media type of the message
+ *
+ * @param {Uint8Array} envelope
+ * @returns {HeaderStub}
+ */
+export const bytesToHeaderStub = (envelope: Uint8Array): HeaderStub => {
+  const tmpObj = headerStubFactory();
+  const str = byteDecoder.decode(envelope);
+  const message = JSON.parse(str);
+  if (!objectIs(message, tmpObj)) {
+    throw new Error(ErrNotHeaderStub);
+  }
+  return message as HeaderStub;
+};

package/src/iden3comm/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './envelope';
+export * from './message';
+export * from './did';
+export * from './accept-profile';

package/src/iden3comm/utils/message.ts

@@ -0,0 +1,41 @@
+import { MediaType } from '../constants';
+import { BasicMessage, EnvelopeStub, HeaderStub, ProtocolMessage } from '../types';
+
+/**
+ * creates empty basic message
+ *
+ * @returns BasicMessage
+ */
+export const basicMessageFactory = (): BasicMessage => {
+  return {
+    id: '',
+    typ: '' as MediaType,
+    thid: '',
+    type: '' as ProtocolMessage,
+    body: {},
+    from: '',
+    to: ''
+  };
+};
+
+/**
+ * create empty envelope stub
+ *
+ * @returns EnvelopeStub
+ */
+export const envelopeStubFactory = (): EnvelopeStub => {
+  return {
+    protected: ''
+  };
+};
+
+/**
+ * create empty header stub
+ *
+ * @returns {HeaderStub}
+ */
+export const headerStubFactory = (): HeaderStub => {
+  return {
+    typ: '' as MediaType
+  };
+};