@0xpolygonid/js-sdk 1.10.4 → 1.11.1

package/dist/node/esm/storage/blockchain/onchain-revocation.js

@@ -1,6 +1,7 @@
 import { Contract, JsonRpcProvider } from 'ethers';
 import { Proof, Hash } from '@iden3/js-merkletree';
 import abi from '../blockchain/abi/CredentialStatusResolver.json';
+import { TransactionService } from '../../blockchain';
 /**
  * OnChainRevocationStore is a class that allows to interact with the onchain contract
  * and build the revocation status.
@@ -26,6 +27,7 @@ export class OnChainRevocationStorage {
             contract = contract.connect(this._signer);
         }
         this._contract = contract;
+        this._transactionService = new TransactionService(this._provider);
     }
     /**
      * Get revocation status by issuerId, issuerState and nonce from the onchain.
@@ -75,18 +77,8 @@ export class OnChainRevocationStorage {
             maxFeePerGas,
             maxPriorityFeePerGas
         };
-        const tx = await this._signer.sendTransaction(request);
-        return tx.wait().then((txReceipt) => {
-            if (!txReceipt) {
-                throw new Error(`transaction: ${tx.hash} failed to mine`);
-            }
-            const status = txReceipt.status;
-            const txnHash = txReceipt.hash;
-            if (!status) {
-                throw new Error(`transaction: ${txnHash} failed to mine`);
-            }
-            return txReceipt;
-        });
+        const { txnReceipt } = await this._transactionService.sendTransactionRequest(this._signer, request);
+        return txnReceipt;
     }
     static convertIssuerInfo(issuer) {
         const [state, claimsTreeRoot, revocationTreeRoot, rootOfRoots] = issuer.map((i) => Hash.fromBigInt(i).hex());

package/dist/node/esm/storage/blockchain/onchain-zkp-verifier.js

@@ -1,5 +1,6 @@
 import { JsonRpcProvider, Contract } from 'ethers';
 import abi from './abi/ZkpVerifier.json';
+import { TransactionService } from '../../blockchain';
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -73,16 +74,8 @@ export class OnChainZKPVerifier {
                 maxFeePerGas,
                 maxPriorityFeePerGas
             };
-            const tx = await ethSigner.sendTransaction(request);
-            const txnReceipt = await tx.wait();
-            if (!txnReceipt) {
-                throw new Error(`transaction: ${tx.hash} failed to mined`);
-            }
-            const status = txnReceipt.status;
-            const txnHash = txnReceipt.hash;
-            if (!status) {
-                throw new Error(`transaction: ${txnHash} failed to mined`);
-            }
+            const transactionService = new TransactionService(provider);
+            const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
             response.set(txnHash, zkProof);
         }
         return response;

package/dist/node/esm/storage/blockchain/state.js

@@ -3,6 +3,7 @@ import { StateTransitionPubSignals } from '../../circuits';
 import { byteEncoder } from '../../utils';
 import abi from './abi/State.json';
 import { DID, getChainId, Id } from '@iden3/js-iden3-core';
+import { TransactionService } from '../../blockchain';
 export /** @type {EthConnectionConfig} - default configuration for EthConnectionConfig */ const defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -33,6 +34,7 @@ export class EthStateStorage {
         const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
         this.provider = new JsonRpcProvider(config.url);
         this.stateContract = new Contract(config.contractAddress, abi, this.provider);
+        this._transactionService = new TransactionService(this.getRpcProvider());
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     async getLatestStateById(id) {
@@ -99,16 +101,39 @@ export class EthStateStorage {
             maxFeePerGas,
             maxPriorityFeePerGas
         };
-        const tx = await signer.sendTransaction(request);
-        const txnReceipt = await tx.wait();
-        if (!txnReceipt) {
-            throw new Error(`transaction: ${tx.hash} failed to mined`);
-        }
-        const status = txnReceipt.status;
-        const txnHash = txnReceipt.hash;
-        if (!status) {
-            throw new Error(`transaction: ${txnHash} failed to mined`);
-        }
+        const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
+        return txnHash;
+    }
+    /** {@inheritdoc IStateStorage.publishStateGeneric} */
+    async publishStateGeneric(signer, userStateTransitionInfo) {
+        const { userId, oldUserState, newUserState, isOldStateGenesis, methodId, methodParams } = userStateTransitionInfo;
+        const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
+        const contract = stateContract.connect(signer);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
+            ? BigInt(defaultEthConnectionConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = defaultEthConnectionConfig.maxPriorityFeePerGas
+            ? BigInt(defaultEthConnectionConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const payload = [
+            userId.bigInt().toString(),
+            oldUserState.bigInt().toString(),
+            newUserState.bigInt().toString(),
+            isOldStateGenesis,
+            methodId,
+            methodParams //'0x'
+        ];
+        const gasLimit = await contract.transitStateGeneric.estimateGas(...payload);
+        const txData = await contract.transitStateGeneric.populateTransaction(...payload);
+        const request = {
+            to: txData.to,
+            data: txData.data,
+            gasLimit,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+        };
+        const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
         return txnHash;
     }
     /** {@inheritdoc IStateStorage.getGISTProof} */
@@ -139,6 +164,10 @@ export class EthStateStorage {
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
     }
+    /** {@inheritdoc IStateStorage.getRpcProvider} */
+    getRpcProvider() {
+        return this.provider;
+    }
     getStateContractAndProviderForId(id) {
         const idTyped = Id.fromBigInt(id);
         if (!Array.isArray(this.ethConfig)) {

package/dist/node/esm/utils/did-helper.js

@@ -1,10 +1,12 @@
 import { Hex } from '@iden3/js-crypto';
 import { Id, buildDIDType, genesisFromEthAddress, DID } from '@iden3/js-iden3-core';
 import { Hash } from '@iden3/js-merkletree';
+import { keccak256 } from 'js-sha3';
+import { hexToBytes } from './encoding';
 /**
  * Checks if state is genesis state
  *
- * @param {string} did - did
+ * @param {DID} did - did
  * @param {bigint|string} state  - hash on bigInt or hex string format
  * @returns boolean
  */
@@ -18,6 +20,24 @@ export function isGenesisState(did, state) {
     const idFromState = Id.idGenesisFromIdenState(type, state);
     return id.bigInt().toString() === idFromState.bigInt().toString();
 }
+/**
+ * Checks if DID is an ethereum identity
+ *
+ * @param {DID} did - did
+ * @returns boolean
+ */
+export function isEthereumIdentity(did) {
+    const issuerId = DID.idFromDID(did);
+    try {
+        Id.ethAddressFromId(issuerId);
+        // is an ethereum identity
+        return true;
+    }
+    catch {
+        // not an ethereum identity (BabyJubJub or other)
+        return false;
+    }
+}
 export const buildVerifierId = (address, info) => {
     address = address.replace('0x', '');
     const ethAddrBytes = Hex.decodeString(address);
@@ -46,3 +66,15 @@ export const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
     const didResolutionRes = (await resp.json());
     return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
 };
+export const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
+    // Use Keccak-256 hash function to get public key hash
+    const hashOfPublicKey = keccak256(hexToBytes(pubKeyEth));
+    // Convert hash to buffer
+    const ethAddressBuffer = hexToBytes(hashOfPublicKey);
+    // Ethereum Address is '0x' concatenated with last 20 bytes
+    // of the public key hash
+    const ethAddr = ethAddressBuffer.slice(-20);
+    const genesis = genesisFromEthAddress(ethAddr);
+    const identifier = new Id(didType, genesis);
+    return DID.parseFromId(identifier);
+};

package/dist/node/esm/verifiable/constants.js

@@ -4,7 +4,8 @@ export const VerifiableConstants = Object.freeze({
         FiELD_IS_EMPTY: 'fieldPath is empty',
         CONTEXT_TYPE_IS_EMPTY: 'ctxType is empty',
         // ErrStateNotFound issuer state is genesis state.
-        IDENTITY_DOES_NOT_EXIST: 'Identity does not exist'
+        IDENTITY_DOES_NOT_EXIST: 'Identity does not exist',
+        NO_AUTH_CRED_FOUND: 'no auth credentials found'
     },
     CREDENTIAL_TYPE: {
         // VerifiableCredential is a W3C verifiable credential type

package/dist/types/blockchain/index.d.ts

@@ -0,0 +1 @@
+export * from './transaction-service';

package/dist/types/blockchain/transaction-service.d.ts

@@ -0,0 +1,80 @@
+import { Block, JsonRpcProvider, Signer, TransactionReceipt, TransactionRequest } from 'ethers';
+/**
+ * Resend transaction options
+ * @type ResendTxnOptions
+ */
+export type ResendTxnOptions = {
+    increasedFeesPercentage?: number;
+};
+/**
+ * Interface for TransactionService
+ * @public
+ */
+export interface ITransactionService {
+    /**
+     * Returns transaction receipt and block by transaction hash
+     *
+     * @param {string} transactionHash - transaction hash.
+     * @returns `Promise<{receipt?: TransactionReceipt , block?: Block}>` - returns transaction receipt and block
+     * @public
+     */
+    getTransactionReceiptAndBlock(transactionHash: string): Promise<{
+        receipt?: TransactionReceipt;
+        block?: Block;
+    }>;
+    /**
+     * Send transaction.
+     *
+     * @param {Signer} signer - transaction signer.
+     * @param {TransactionRequest} request - transaction request.
+     * @returns `Promise<txnHash: string, txnReceipt: TransactionReceipt` - returns txn hash and txn receipt.
+     * @public
+     */
+    sendTransactionRequest(signer: Signer, request: TransactionRequest): Promise<{
+        txnHash: string;
+        txnReceipt: TransactionReceipt;
+    }>;
+    /**
+     * Resend transaction with options. Useful when `transaction underpriced` error thrown on transaction.
+     *
+     * @param {Signer} signer - transaction signer.
+     * @param {TransactionRequest} request - transaction request.
+     * @param {ResendTxnOptions} opts - resend transaction options.
+     * @returns `Promise<{ txnHash: string; txnReceipt: TransactionReceipt }>` -returns txn hash and txn receipt.
+     * @public
+     */
+    resendTransaction(signer: Signer, request: TransactionRequest, opts?: ResendTxnOptions): Promise<{
+        txnHash: string;
+        txnReceipt: TransactionReceipt;
+    }>;
+}
+/**
+ * Transaction service to provide interaction with blockchain transactions.
+ * allows to: get tx receipt by tx id, send and resend transaction with new fees.
+ * @class TransactionService
+ * @public
+ * @implements ITransactionService interface
+ */
+export declare class TransactionService implements ITransactionService {
+    private readonly _provider;
+    /**
+     * Creates an instance of TransactionService.
+     * @param {JsonRpcProvider} - RPC provider
+     */
+    constructor(_provider: JsonRpcProvider);
+    /** {@inheritDoc ITransactionService.getTransactionReceiptAndBlock} */
+    getTransactionReceiptAndBlock(txnHash: string): Promise<{
+        receipt?: TransactionReceipt;
+        block?: Block;
+    }>;
+    /** {@inheritDoc ITransactionService.sendTransactionRequest} */
+    sendTransactionRequest(signer: Signer, request: TransactionRequest): Promise<{
+        txnHash: string;
+        txnReceipt: TransactionReceipt;
+    }>;
+    /** {@inheritDoc ITransactionService.resendTransaction} */
+    resendTransaction(signer: Signer, request: TransactionRequest, opts?: ResendTxnOptions): Promise<{
+        txnHash: string;
+        txnReceipt: TransactionReceipt;
+    }>;
+}

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

@@ -1,7 +1,8 @@
 import { MediaType } from '../constants';
 import { IProofService } from '../../proof/proof-service';
-import { AuthorizationRequestMessage, AuthorizationResponseMessage, IPackageManager, JWSPackerParams } from '../types';
+import { AuthorizationRequestMessage, AuthorizationResponseMessage, BasicMessage, IPackageManager, JWSPackerParams } from '../types';
 import { DID } from '@iden3/js-iden3-core';
+import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
@@ -76,6 +77,16 @@ export interface IAuthHandler {
         response: AuthorizationResponseMessage;
     }>;
 }
+type AuthReqOptions = {
+    senderDid: DID;
+    mediaType?: MediaType;
+};
+type AuthRespOptions = {
+    request: AuthorizationRequestMessage;
+    acceptedStateTransitionDelay?: number;
+    acceptedProofGenerationDelay?: number;
+};
+export type AuthMessageHandlerOptions = AuthReqOptions | AuthRespOptions;
 /**
  *
  * Options to pass to auth handler
@@ -96,7 +107,7 @@ export interface AuthHandlerOptions {
  * @class AuthHandler
  * @implements implements IAuthHandler interface
  */
-export declare class AuthHandler implements IAuthHandler {
+export declare class AuthHandler extends AbstractMessageHandler implements IAuthHandler, IProtocolMessageHandler {
     private readonly _packerMgr;
     private readonly _proofService;
     private readonly _supportedCircuits;
@@ -107,10 +118,12 @@ export declare class AuthHandler implements IAuthHandler {
      *
      */
     constructor(_packerMgr: IPackageManager, _proofService: IProofService);
+    handle(message: BasicMessage, ctx: AuthMessageHandlerOptions): Promise<BasicMessage | null>;
     /**
      * @inheritdoc IAuthHandler#parseAuthorizationRequest
      */
     parseAuthorizationRequest(request: Uint8Array): Promise<AuthorizationRequestMessage>;
+    private handleAuthRequest;
     /**
      * @inheritdoc IAuthHandler#handleAuthorizationRequest
      */
@@ -119,6 +132,7 @@ export declare class AuthHandler implements IAuthHandler {
         authRequest: AuthorizationRequestMessage;
         authResponse: AuthorizationResponseMessage;
     }>;
+    private handleAuthResponse;
     /**
      * @inheritdoc IAuthHandler#handleAuthorizationResponse
      */
@@ -128,3 +142,4 @@ export declare class AuthHandler implements IAuthHandler {
     }>;
     private verifyAuthRequest;
 }
+export {};

package/dist/types/iden3comm/handlers/common.d.ts

@@ -7,14 +7,14 @@ import { Signer } from 'ethers';
 /**
  * Processes zero knowledge proof requests.
  *
- * @param senderIdentifier - The identifier of the sender.
+ * @param to - The identifier of the recipient.
  * @param requests - An array of zero knowledge proof requests.
  * @param from - The identifier of the sender.
  * @param proofService - The proof service.
  * @param opts - Additional options for processing the requests.
  * @returns A promise that resolves to an array of zero knowledge proof responses.
  */
-export declare const processZeroKnowledgeProofRequests: (senderIdentifier: DID, requests: ZeroKnowledgeProofRequest[] | undefined, from: DID | undefined, proofService: IProofService, opts: {
+export declare const processZeroKnowledgeProofRequests: (to: DID, requests: ZeroKnowledgeProofRequest[] | undefined, from: DID | undefined, proofService: IProofService, opts: {
     mediaType?: MediaType;
     packerOptions?: JWSPackerParams;
     supportedCircuits: CircuitId[];

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

@@ -1,9 +1,10 @@
 import { IProofService } from '../../proof/proof-service';
-import { IPackageManager, ZeroKnowledgeProofResponse } from '../types';
+import { BasicMessage, IPackageManager, ZeroKnowledgeProofResponse } from '../types';
 import { ContractInvokeRequest } from '../types/protocol/contract-request';
 import { DID } from '@iden3/js-iden3-core';
 import { IOnChainZKPVerifier } from '../../storage';
 import { Signer } from 'ethers';
+import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
 /**
  * Interface that allows the processing of the contract request
  *
@@ -33,6 +34,11 @@ export type ContractInvokeHandlerOptions = {
     ethSigner: Signer;
     challenge?: bigint;
 };
+export type ContractMessageHandlerOptions = {
+    senderDid: DID;
+    ethSigner: Signer;
+    challenge?: bigint;
+};
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -42,7 +48,7 @@ export type ContractInvokeHandlerOptions = {
  * @class ContractRequestHandler
  * @implements implements IContractRequestHandler interface
  */
-export declare class ContractRequestHandler implements IContractRequestHandler {
+export declare class ContractRequestHandler extends AbstractMessageHandler implements IContractRequestHandler, IProtocolMessageHandler {
     private readonly _packerMgr;
     private readonly _proofService;
     private readonly _zkpVerifier;
@@ -55,6 +61,8 @@ export declare class ContractRequestHandler implements IContractRequestHandler {
      *
      */
     constructor(_packerMgr: IPackageManager, _proofService: IProofService, _zkpVerifier: IOnChainZKPVerifier);
+    handle(message: BasicMessage, ctx: ContractMessageHandlerOptions): Promise<BasicMessage | null>;
+    private handleContractInvoke;
     /**
      * unpacks contract-invoke request
      * @beta

package/dist/types/iden3comm/handlers/credential-proposal.d.ts

@@ -1,7 +1,8 @@
-import { IPackageManager, JSONObject, PackerParams } from '../types';
+import { BasicMessage, IPackageManager, JSONObject, PackerParams } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { Proposal, ProposalRequestCredential, ProposalRequestMessage, ProposalMessage } from '../types/protocol/proposal-request';
 import { IIdentityWallet } from '../../identity';
+import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
 /** @beta ProposalRequestCreationOptions represents proposal-request creation options */
 export type ProposalRequestCreationOptions = {
     credentials: ProposalRequestCredential[];
@@ -83,7 +84,7 @@ export type CredentialProposalHandlerParams = {
  * @class CredentialProposalHandler
  * @implements implements ICredentialProposalHandler interface
  */
-export declare class CredentialProposalHandler implements ICredentialProposalHandler {
+export declare class CredentialProposalHandler extends AbstractMessageHandler implements ICredentialProposalHandler, IProtocolMessageHandler {
     private readonly _packerMgr;
     private readonly _identityWallet;
     private readonly _params;
@@ -95,10 +96,12 @@ export declare class CredentialProposalHandler implements ICredentialProposalHan
      *
      */
     constructor(_packerMgr: IPackageManager, _identityWallet: IIdentityWallet, _params: CredentialProposalHandlerParams);
+    handle(message: BasicMessage, context: ProposalRequestHandlerOptions): Promise<BasicMessage | null>;
     /**
      * @inheritdoc ICredentialProposalHandler#parseProposalRequest
      */
     parseProposalRequest(request: Uint8Array): Promise<ProposalRequestMessage>;
+    private handleProposalRequestMessage;
     /**
      * @inheritdoc ICredentialProposalHandler#handleProposalRequest
      */

package/dist/types/iden3comm/handlers/fetch.d.ts

@@ -1,7 +1,8 @@
 import { MediaType } from '../constants';
-import { IPackageManager, JWSPackerParams } from '../types';
+import { BasicMessage, IPackageManager, JWSPackerParams } from '../types';
 import { W3CCredential } from '../../verifiable';
 import { ICredentialWallet } from '../../credentials';
+import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
 /**
  *
  * Options to pass to fetch handler
@@ -9,13 +10,14 @@ import { ICredentialWallet } from '../../credentials';
  * @public
  * @interface FetchHandlerOptions
  */
-export interface FetchHandlerOptions {
+export type FetchHandlerOptions = {
     mediaType: MediaType;
     packerOptions?: JWSPackerParams;
     headers?: {
         [key: string]: string;
     };
-}
+};
+export type FetchMessageHandlerOptions = FetchHandlerOptions;
 /**
  * Interface that allows the processing of the credential offer in the raw format for given identifier
  *
@@ -61,16 +63,21 @@ export interface IFetchHandler {
  * @class FetchHandler
  * @implements implements IFetchHandler interface
  */
-export declare class FetchHandler implements IFetchHandler {
+export declare class FetchHandler extends AbstractMessageHandler implements IFetchHandler, IProtocolMessageHandler {
     private readonly _packerMgr;
     private readonly opts?;
     /**
-     * Creates an instance of FetchHandler.
-     * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+     * Constructs a new instance of the FetchHandler class.
+     *
+     * @param _packerMgr The package manager used for packing and unpacking data.
+     * @param opts Optional configuration options for the FetchHandler.
+     * @param opts.credentialWallet The credential wallet used for managing credentials.
      */
     constructor(_packerMgr: IPackageManager, opts?: {
         credentialWallet: ICredentialWallet;
     } | undefined);
+    handle(message: BasicMessage, ctx: FetchMessageHandlerOptions): Promise<BasicMessage | null>;
+    private handleOfferMessage;
     /**
      * Handles only messages with credentials/1.0/offer type
      *
@@ -81,10 +88,12 @@ export declare class FetchHandler implements IFetchHandler {
      * @returns `Promise<W3CCredential[]>`
      */
     handleCredentialOffer(offer: Uint8Array, opts?: FetchHandlerOptions): Promise<W3CCredential[]>;
+    private handleFetchRequest;
     /**
      * @inheritdoc IFetchHandler#handleCredentialFetchRequest
      */
     handleCredentialFetchRequest(envelope: Uint8Array): Promise<Uint8Array>;
+    private handleIssuanceResponseMsg;
     /**
      * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
      */

package/dist/types/iden3comm/handlers/index.d.ts

@@ -5,3 +5,4 @@ export * from './refresh';
 export * from './revocation-status';
 export * from './common';
 export * from './credential-proposal';
+export * from './message-handler';

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;