@0xpolygonid/js-sdk 1.10.3 → 1.11.0

package/dist/types/iden3comm/handlers/message-handler.d.ts

@@ -0,0 +1,83 @@
+import { BasicMessage, IPackageManager } from '../types';
+import { AuthMessageHandlerOptions } from './auth';
+import { RevocationStatusMessageHandlerOptions } from './revocation-status';
+import { ContractMessageHandlerOptions } from './contract-request';
+/**
+ * iden3  Protocol message handler interface
+ */
+export interface IProtocolMessageHandler {
+    /**
+     * Handel message implementation
+     *
+     * @param {BasicMessage} message
+     * @param {{ [key: string]: unknown }} ctx context
+     * @returns {(Promise<BasicMessage | null>)}
+     * @memberof IProtocolMessageHandler
+     */
+    handle(message: BasicMessage, ctx: {
+        [key: string]: unknown;
+    }): Promise<BasicMessage | null>;
+}
+/**
+ * Base implementation of protocol message handler
+ *
+ * @export
+ * @abstract
+ * @class AbstractMessageHandler
+ * @implements {IProtocolMessageHandler}
+ */
+export declare abstract class AbstractMessageHandler implements IProtocolMessageHandler {
+    nextMessageHandler?: AbstractMessageHandler;
+    setNext(messageHandler: AbstractMessageHandler): AbstractMessageHandler;
+    handle(message: BasicMessage, context: {
+        [key: string]: unknown;
+    }): Promise<BasicMessage | null>;
+}
+/**
+ * Protocol message handler entry point
+ */
+export declare class MessageHandler {
+    private readonly _params;
+    private messageHandler?;
+    /**
+     * Creates an instance of MessageHandler.
+     * @param {{
+     *       messageHandlers: AbstractMessageHandler[];
+     *       packageManager: IPackageManager;
+     *     }} _params
+     * @memberof MessageHandler
+     */
+    constructor(_params: {
+        messageHandlers: AbstractMessageHandler[];
+        packageManager: IPackageManager;
+    });
+    /**
+     * Registers a list of message handlers and sets up the chain of responsibility.
+     *
+     * This method takes an array of `AbstractMessageHandler` instances and sets up a chain of responsibility
+     * where each handler is linked to the next one in the array. The first handler in the array becomes the
+     * main message handler for the `MessageHandler` class.
+     *
+     * @param {AbstractMessageHandler[]} handlersList - An array of `AbstractMessageHandler` instances to be registered.
+     * @returns {void}
+     */
+    registerHandlers(handlersList: AbstractMessageHandler[]): void;
+    /**
+     * Handles a message by unpacking it, passing it to the registered message handler, and packing the response.
+     *
+     * This method takes a Uint8Array of message bytes and a context object that contains information specific to the
+     * type of message being handled (e.g. AuthMessageHandlerOptions, ContractMessageHandlerOptions, etc.).
+     *
+     * The method first unpacks the message using the provided package manager, then passes the unpacked message and
+     * context to the registered message handler. If the message handler returns a response, the method packs the
+     * response using the package manager and returns it. If the message handler does not return a response, the
+     * method returns null.
+     *
+     * @param bytes - A Uint8Array of message bytes to be handled.
+     * @param context - An object containing information specific to the type of message being handled.
+     * @returns A Promise that resolves to a Uint8Array of the packed response, or null if no response was generated.
+     */
+    handleMessage(bytes: Uint8Array, context: AuthMessageHandlerOptions | ContractMessageHandlerOptions | RevocationStatusMessageHandlerOptions | ContractMessageHandlerOptions | {
+        [key: string]: unknown;
+    }): Promise<Uint8Array | null>;
+}

package/dist/types/iden3comm/handlers/revocation-status.d.ts

@@ -1,8 +1,22 @@
 import { MediaType } from '../constants';
-import { IPackageManager, JWSPackerParams, RevocationStatusRequestMessage } from '../types';
+import { BasicMessage, IPackageManager, JWSPackerParams, RevocationStatusRequestMessage } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { TreeState } from '../../circuits';
 import { IIdentityWallet } from '../../identity';
+import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+/**
+ * Defines the options for a RevocationStatusMessageHandler.
+ * @property did - 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 = {
+    did: DID;
+    mediaType: MediaType;
+    packerOptions?: JWSPackerParams;
+    treeState?: TreeState;
+};
 /**
  * Interface that allows the processing of the revocation status
  *
@@ -38,7 +52,7 @@ export type RevocationStatusHandlerOptions = {
  * @class RevocationStatusHandler
  * @implements implements IRevocationStatusHandler interface
  */
-export declare class RevocationStatusHandler implements IRevocationStatusHandler {
+export declare class RevocationStatusHandler extends AbstractMessageHandler implements IRevocationStatusHandler, IProtocolMessageHandler {
     private readonly _packerMgr;
     private readonly _identityWallet;
     /**
@@ -48,6 +62,8 @@ export declare class RevocationStatusHandler implements IRevocationStatusHandler
      *
      */
     constructor(_packerMgr: IPackageManager, _identityWallet: IIdentityWallet);
+    handle(message: BasicMessage, context: RevocationStatusMessageHandlerOptions): Promise<BasicMessage | null>;
+    private handleRevocationStatusRequestMessage;
     /**
      * @inheritdoc IRevocationStatusHandler#parseRevocationStatusRequest
      */

package/dist/types/iden3comm/packageManager.d.ts

@@ -17,6 +17,16 @@ export declare class PackageManager implements IPackageManager {
     registerPackers(packers: Array<IPacker>): void;
     /** {@inheritDoc IPackageManager.pack} */
     pack(mediaType: MediaType, payload: Uint8Array, params: PackerParams): Promise<Uint8Array>;
+    /**
+     * 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>;
     /** {@inheritDoc IPackageManager.unpack} */
     unpack(envelope: Uint8Array): Promise<{
         unpackedMessage: BasicMessage;

package/dist/types/iden3comm/packers/jws.d.ts

@@ -20,6 +20,14 @@ export declare class JWSPacker implements IPacker {
      * @memberof JWSPacker
      */
     constructor(_kms: KMS, _documentResolver: Resolvable);
+    /**
+     * Packs the given payload and returns a promise that resolves to the packed data.
+     *
+     * @param {Uint8Array} payload - The payload to be packed.
+     * @param {PackerParams} param - The packing parameters.
+     * @returns `Promise<Uint8Array>`
+     */
+    packMessage(msg: BasicMessage, param: JWSPackerParams): Promise<Uint8Array>;
     /**
      * creates JSON Web Signature token
      *
@@ -37,4 +45,5 @@ export declare class JWSPacker implements IPacker {
     unpack(envelope: Uint8Array): Promise<BasicMessage>;
     mediaType(): MediaType;
     private resolveDidDoc;
+    private packInternal;
 }

package/dist/types/iden3comm/packers/plain.d.ts

@@ -1,4 +1,3 @@
-import { PlainPackerParams } from './../types/packer';
 import { BasicMessage, IPacker } from '../types';
 import { MediaType } from '../constants';
 /**
@@ -9,6 +8,15 @@ import { MediaType } from '../constants';
  * @implements implements IPacker interface
  */
 export declare class PlainPacker implements IPacker {
+    /**
+     * Packs a basic message using the specified parameters.
+     *
+     * @param msg - The basic message to pack.
+     * @param param - The packer parameters.
+     * @returns A promise that resolves to a Uint8Array representing the packed message.
+     * @throws An error if the method is not implemented.
+     */
+    packMessage(msg: BasicMessage): Promise<Uint8Array>;
     /**
      * Pack returns packed message to transport envelope
      *
@@ -16,7 +24,7 @@ export declare class PlainPacker implements IPacker {
      * @param {PlainPackerParams} _params - not used here
      * @returns `Promise<Uint8Array>`
      */
-    pack(payload: Uint8Array, _params: PlainPackerParams): Promise<Uint8Array>;
+    pack(payload: Uint8Array): Promise<Uint8Array>;
     /**
      * Unpack returns unpacked message from transport envelope
      *

package/dist/types/iden3comm/packers/zkp.d.ts

@@ -63,6 +63,13 @@ export declare class ZKPPacker implements IPacker {
      * @param {Map<string, VerificationParams>} verificationParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
      */
     constructor(provingParamsMap: Map<string, ProvingParams>, verificationParamsMap: Map<string, VerificationParams>);
+    /**
+     * Packs a basic message using the specified parameters.
+     * @param msg - The basic message to pack.
+     * @param param - The parameters for the ZKPPacker.
+     * @returns A promise that resolves to a Uint8Array representing the packed message.
+     */
+    packMessage(msg: BasicMessage, param: ZKPPackerParams): Promise<Uint8Array>;
     /**
      * creates JSON Web Zeroknowledge token
      *

package/dist/types/iden3comm/types/packageManager.d.ts

@@ -29,6 +29,16 @@ export interface IPackageManager {
      * @returns `Promise<Uint8Array>`
      */
     pack(mediaType: MediaType, payload: Uint8Array, params: PackerParams): Promise<Uint8Array>;
+    /**
+     * packs payload with a packer that is assigned to media type
+     * forwards packer params to implementation
+     *
+     * @param {MediaType} mediaType
+     * @param {BasicMessage} protocolMessage
+     * @param {PackerParams} params
+     * @returns `Promise<Uint8Array>`
+     */
+    packMessage(mediaType: MediaType, protocolMessage: BasicMessage, params: PackerParams): Promise<Uint8Array>;
     /**
      * unpacks packed envelope to basic protocol message and returns media type of the envelope
      *

package/dist/types/iden3comm/types/packer.d.ts

@@ -4,7 +4,6 @@ import { ProvingMethodAlg } from '@iden3/js-jwz';
 import { CircuitId } from '../../circuits';
 import { MediaType } from '../constants';
 import { DIDDocument, VerificationMethod } from 'did-resolver';
-import { Signer } from 'did-jwt';
 /**
  *  Protocol message type
  */
@@ -45,8 +44,9 @@ export type ZKPPackerParams = PackerParams & {
 };
 /**
  *  SignerFn Is function to sign data with a verification method
+ *  @returns Promise of signature bytes;
  */
-export type SignerFn = (vm: VerificationMethod, data: Uint8Array) => Signer;
+export type SignerFn = (vm: VerificationMethod, dataToSign: Uint8Array) => Promise<Uint8Array>;
 /**
  *  JWSPackerParams are parameters for JWS packer
  */
@@ -75,8 +75,30 @@ export type StateVerificationFunc = (id: string, pubSignals: Array<string>) => P
  * @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;
 }
 /**

package/dist/types/iden3comm/types/protocol/auth.d.ts

@@ -1,16 +1,11 @@
 import { ZKProof } from '@iden3/js-jwz';
-import { MediaType } from '../../constants';
-import { JSONObject, ProtocolMessage } from '../packer';
+import { BasicMessage, JSONObject } from '../packer';
 import { DID } from '@iden3/js-iden3-core';
 /** AuthorizationResponseMessage is struct the represents iden3message authorization response */
-export type AuthorizationResponseMessage = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type AuthorizationResponseMessage = BasicMessage & {
     body: AuthorizationMessageResponseBody;
-    from?: string;
-    to?: string;
+    from: string;
+    to: string;
 };
 /** AuthorizationMessageResponseBody is struct the represents authorization response data */
 export type AuthorizationMessageResponseBody = {
@@ -19,14 +14,9 @@ export type AuthorizationMessageResponseBody = {
     scope: Array<ZeroKnowledgeProofResponse>;
 };
 /** AuthorizationRequestMessage is struct the represents iden3message authorization request */
-export type AuthorizationRequestMessage = {
-    id: string;
-    typ: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type AuthorizationRequestMessage = BasicMessage & {
     body: AuthorizationRequestMessageBody;
     from: string;
-    to?: string;
 };
 /** AuthorizationRequestMessageBody is body for authorization request */
 export type AuthorizationRequestMessageBody = {

package/dist/types/iden3comm/types/protocol/contract-request.d.ts

@@ -1,12 +1,8 @@
+import { BasicMessage } from '../packer';
 import { ZeroKnowledgeProofRequest } from './auth';
 /** ContractInvokeRequest represents structure of contract invoke request object */
-export type ContractInvokeRequest = {
-    id: string;
-    typ: string;
-    type: string;
-    thid: string;
+export type ContractInvokeRequest = BasicMessage & {
     body: ContractInvokeRequestBody;
-    from?: string;
 };
 /** ContractInvokeRequestBody represents structure of contract invoke request body object */
 export type ContractInvokeRequestBody = {

package/dist/types/iden3comm/types/protocol/credentials.d.ts

@@ -1,6 +1,5 @@
 import { W3CCredential } from '../../../verifiable';
-import { MediaType } from '../../constants';
-import { JSONObject, ProtocolMessage } from '../packer';
+import { BasicMessage, JSONObject } from '../packer';
 import { ContractInvokeTransactionData } from './contract-request';
 /** CredentialIssuanceRequestMessageBody represents data for credential issuance request */
 export type CredentialIssuanceRequestMessageBody = {
@@ -9,24 +8,12 @@ export type CredentialIssuanceRequestMessageBody = {
     expiration: number;
 };
 /** CredentialIssuanceRequestMessage represent Iden3message for credential request */
-export type CredentialIssuanceRequestMessage = {
-    id: string;
-    typ: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type CredentialIssuanceRequestMessage = Required<BasicMessage> & {
     body: CredentialIssuanceRequestMessageBody;
-    from: string;
-    to: string;
 };
 /** CredentialsOfferMessage represent Iden3message for credential offer */
-export type CredentialsOfferMessage = {
-    id: string;
-    typ: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type CredentialsOfferMessage = Required<BasicMessage> & {
     body: CredentialsOfferMessageBody;
-    from: string;
-    to: string;
 };
 /** CredentialsOfferMessageBody is struct the represents offer message */
 export type CredentialsOfferMessageBody = {
@@ -34,14 +21,8 @@ export type CredentialsOfferMessageBody = {
     credentials: Array<CredentialOffer>;
 };
 /** CredentialsOnchainOfferMessage represent Iden3message for credential onhcain offer message */
-export type CredentialsOnchainOfferMessage = {
-    id: string;
-    typ: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type CredentialsOnchainOfferMessage = Required<BasicMessage> & {
     body: CredentialsOnchainOfferMessageBody;
-    from: string;
-    to: string;
 };
 /** CredentialsOnchainOfferMessageBody is struct the represents onchain offer message body */
 export type CredentialsOnchainOfferMessageBody = {
@@ -54,28 +35,16 @@ export type CredentialOffer = {
     description: string;
 };
 /** CredentialIssuanceMessage represent Iden3message for credential issuance */
-export type CredentialIssuanceMessage = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    threadID?: string;
+export type CredentialIssuanceMessage = Required<BasicMessage> & {
     body?: IssuanceMessageBody;
-    from?: string;
-    to?: string;
 };
 /** 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 = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type CredentialFetchRequestMessage = BasicMessage & {
     body?: CredentialFetchRequestMessageBody;
-    from?: string;
-    to?: string;
 };
 /** CredentialFetchRequestMessageBody is msg body for fetch request */
 export type CredentialFetchRequestMessageBody = {
@@ -88,14 +57,8 @@ export type Schema = {
     type: string;
 };
 /** CredentialRefreshMessage represent Iden3message for credential refresh request */
-export type CredentialRefreshMessage = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type CredentialRefreshMessage = Required<BasicMessage> & {
     body?: CredentialRefreshMessageBody;
-    from?: string;
-    to?: string;
 };
 /** CredentialRefreshMessageBody is msg body for refresh request */
 export type CredentialRefreshMessageBody = {

package/dist/types/iden3comm/types/protocol/messages.d.ts

@@ -1,14 +1,7 @@
-import { ProtocolMessage } from '../';
-import { MediaType } from '../../constants';
+import { BasicMessage } from '../';
 /**  MessageFetchRequestMessage represent Iden3message for message fetch request. */
-export type MessageFetchRequestMessage = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type MessageFetchRequestMessage = Required<BasicMessage> & {
     body?: MessageFetchRequestMessageBody;
-    from?: string;
-    to?: string;
 };
 /** MessageFetchRequestMessageBody is struct the represents body for message fetch request. */
 export type MessageFetchRequestMessageBody = {

package/dist/types/iden3comm/types/protocol/proof.d.ts

@@ -1,29 +1,16 @@
-import { ProtocolMessage } from '../';
-import { MediaType } from '../../constants';
+import { BasicMessage } from '../';
 import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from './auth';
 /** ProofGenerationRequestMessage is struct the represents body for proof generation request */
-export type ProofGenerationRequestMessage = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type ProofGenerationRequestMessage = Required<BasicMessage> & {
     body?: ProofGenerationRequestMessageBody;
-    from?: string;
-    to?: string;
 };
 /** 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 = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type ProofGenerationResponseMessage = Required<BasicMessage> & {
     body?: ResponseMessageBody;
-    from?: string;
-    to?: string;
 };
 /** ResponseMessageBody is struct the represents request for revocation status */
 export type ResponseMessageBody = {

package/dist/types/iden3comm/types/protocol/revocation.d.ts

@@ -1,29 +1,16 @@
-import { ProtocolMessage } from '../';
+import { BasicMessage } from '../';
 import { RevocationStatus } from '../../../verifiable';
-import { MediaType } from '../../constants';
 /** RevocationStatusRequestMessage is struct the represents body for proof generation request */
-export type RevocationStatusRequestMessage = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type RevocationStatusRequestMessage = BasicMessage & {
     body?: RevocationStatusRequestMessageBody;
-    from?: string;
-    to?: string;
 };
 /** 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 = {
-    id: string;
-    typ?: MediaType;
-    type: ProtocolMessage;
-    thid?: string;
+export type RevocationStatusResponseMessage = Required<BasicMessage> & {
     body?: RevocationStatusResponseMessageBody;
-    from?: string;
-    to?: string;
 };
 /** RevocationStatusResponseMessageBody is struct the represents request for revocation status */
 export type RevocationStatusResponseMessageBody = RevocationStatus;