@0xpolygonid/js-sdk 1.10.3 → 1.11.0

package/dist/node/esm/proof/proof-service.js

@@ -1,7 +1,6 @@
-import { Poseidon } from '@iden3/js-crypto';
 import { BytesHelper, DID, MerklizedRootPosition } from '@iden3/js-iden3-core';
 import { Hash } from '@iden3/js-merkletree';
-import { AuthV2Inputs, CircuitId, Operators, Query, StateTransitionInputs, ValueProof } from '../circuits';
+import { AuthV2Inputs, CircuitId, Operators, Query, ValueProof } from '../circuits';
 import { createVerifiablePresentation } from '../verifiable';
 import { parseCredentialSubject, parseQueryMetadata, toGISTProof, transformQueryValueToBigInts } from './common';
 import { NativeProver } from './provers/prover';
@@ -130,38 +129,9 @@ export class ProofService {
         };
     }
     /** {@inheritdoc IProofService.transitState} */
-    async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, ethSigner) {
-        const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
-        const newTreeModel = await this._identityWallet.getDIDTreeModel(did);
-        const claimsRoot = await newTreeModel.claimsTree.root();
-        const rootOfRoots = await newTreeModel.rootsTree.root();
-        const revocationRoot = await newTreeModel.revocationTree.root();
-        const newTreeState = {
-            revocationRoot,
-            claimsRoot,
-            state: newTreeModel.state,
-            rootOfRoots
-        };
-        const challenge = Poseidon.hash([oldTreeState.state.bigInt(), newTreeState.state.bigInt()]);
-        const signature = await this._identityWallet.signChallenge(challenge, authInfo.credential);
-        const circuitInputs = new StateTransitionInputs();
-        circuitInputs.id = DID.idFromDID(did);
-        circuitInputs.signature = signature;
-        circuitInputs.isOldStateGenesis = isOldStateGenesis;
-        const authClaimIncProofNewState = await this._identityWallet.generateCredentialMtp(did, authInfo.credential, newTreeState);
-        circuitInputs.newTreeState = authClaimIncProofNewState.treeState;
-        circuitInputs.authClaimNewStateIncProof = authClaimIncProofNewState.proof;
-        circuitInputs.oldTreeState = oldTreeState;
-        circuitInputs.authClaim = {
-            claim: authInfo.coreClaim,
-            incProof: authInfo.incProof,
-            nonRevProof: authInfo.nonRevProof
-        };
-        const inputs = circuitInputs.inputsMarshal();
-        const proof = await this._prover.generate(inputs, CircuitId.StateTransition);
-        const txId = await stateStorage.publishState(proof, ethSigner);
-        await this._identityWallet.updateIdentityState(did, true, newTreeState);
-        return txId;
+    async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, // for compatibility with previous versions we leave this parameter
+    ethSigner) {
+        return this._identityWallet.transitState(did, oldTreeState, isOldStateGenesis, ethSigner, this._prover);
     }
     async generateInputs(preparedCredential, identifier, proofReq, params, circuitQueries) {
         return this._inputsGenerator.generateInputs({

package/dist/node/esm/proof/provers/inputs-generator.js

@@ -1,8 +1,9 @@
-import { DID, Id, getUnixTimestamp } from '@iden3/js-iden3-core';
+import { DID, getUnixTimestamp } from '@iden3/js-iden3-core';
 import { ProofType } from '../../verifiable';
 import { AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainInputs, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, CircuitClaim, CircuitId, LinkedMultiQueryInputs, Operators, QueryOperators, ValueProof, getOperatorNameByValue } from '../../circuits';
 import { toClaimNonRevStatus, toGISTProof } from '../common';
 import { getUserDIDFromCredential } from '../../credentials';
+import { isEthereumIdentity } from '../../utils';
 const allOperations = Object.values(QueryOperators);
 const v2Operations = [
     Operators.NOOP,
@@ -266,13 +267,7 @@ export class InputGenerator {
             circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionId
                 ? BigInt(proofReq.params?.nullifierSessionId?.toString())
                 : BigInt(0);
-            let isEthIdentity = true;
-            try {
-                Id.ethAddressFromId(circuitInputs.id);
-            }
-            catch {
-                isEthIdentity = false;
-            }
+            const isEthIdentity = isEthereumIdentity(identifier);
             circuitInputs.isBJJAuthEnabled = isEthIdentity ? 0 : 1;
             circuitInputs.challenge = BigInt(params.challenge ?? 0);
             const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);

package/dist/node/esm/proof/verifiers/pub-signals-verifier.js

@@ -294,10 +294,7 @@ export class PubSignalsVerifier {
             }
         };
         this.checkStateExistenceForId = async (userId, userState) => {
-            const { latest } = await this.resolve(userId, userState.bigInt());
-            if (!latest) {
-                throw userStateError;
-            }
+            await this.resolve(userId, userState.bigInt());
         };
         this.checkGlobalState = async (state, id) => {
             return this.rootResolve(state.bigInt(), id.bigInt());
@@ -390,7 +387,9 @@ export class PubSignalsVerifier {
             contractState = await this._stateStorage.getStateInfoByIdAndState(idBigInt, state);
         }
         catch (e) {
-            if (e.errorArgs[0] === 'State does not exist') {
+            const stateNotExistErr = (e?.errorArgs ?? [])[0];
+            const errMsg = stateNotExistErr || e.message;
+            if (errMsg === 'State does not exist') {
                 if (isGenesis) {
                     return {
                         latest: true,

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';