@0xpolygonid/js-sdk 1.10.3 → 1.11.0

package/dist/node/cjs/blockchain/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./transaction-service"), exports);

package/dist/node/cjs/blockchain/transaction-service.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+/**
+ * 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
+ */
+class TransactionService {
+    /**
+     * Creates an instance of TransactionService.
+     * @param {JsonRpcProvider} - RPC provider
+     */
+    constructor(_provider) {
+        this._provider = _provider;
+    }
+    /** {@inheritDoc ITransactionService.getTransactionReceiptAndBlock} */
+    async getTransactionReceiptAndBlock(txnHash) {
+        const receipt = await this._provider.getTransactionReceipt(txnHash);
+        const block = await receipt?.getBlock();
+        return { receipt: receipt || undefined, block };
+    }
+    /** {@inheritDoc ITransactionService.sendTransactionRequest} */
+    async sendTransactionRequest(signer, request) {
+        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`);
+        }
+        return { txnHash, txnReceipt };
+    }
+    /** {@inheritDoc ITransactionService.resendTransaction} */
+    async resendTransaction(signer, request, opts) {
+        const feeData = await this._provider.getFeeData();
+        let { maxFeePerGas, maxPriorityFeePerGas, gasPrice } = feeData;
+        if (opts?.increasedFeesPercentage) {
+            const multiplyVal = BigInt((opts.increasedFeesPercentage + 100) / 100);
+            maxFeePerGas = maxFeePerGas ? maxFeePerGas * multiplyVal : null;
+            maxPriorityFeePerGas = maxPriorityFeePerGas ? maxPriorityFeePerGas * multiplyVal : null;
+            gasPrice = gasPrice ? gasPrice * multiplyVal : null;
+        }
+        request.maxFeePerGas = maxFeePerGas;
+        request.maxPriorityFeePerGas = maxPriorityFeePerGas;
+        request.gasPrice = gasPrice;
+        return this.sendTransactionRequest(signer, request);
+    }
+}
+exports.TransactionService = TransactionService;

package/dist/node/cjs/credentials/credential-wallet.js

@@ -104,7 +104,7 @@ class CredentialWallet {
             allowedIssuers: [did.string()]
         });
         if (!authBJJCredsOfIssuer.length) {
-            throw new Error('no auth credentials found');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.NO_AUTH_CRED_FOUND);
         }
         for (let index = 0; index < authBJJCredsOfIssuer.length; index++) {
             const authCred = authBJJCredsOfIssuer[index];

package/dist/node/cjs/credentials/status/reverse-sparse-merkle-tree.js

@@ -136,9 +136,13 @@ class RHSResolver {
                 return this.getRevocationStatusFromIssuerData(issuerDID, issuerData, genesisState);
             }
             const currentStateBigInt = js_merkletree_1.Hash.fromHex(stateHex).bigInt();
-            if (!(0, utils_1.isGenesisState)(issuerDID, currentStateBigInt)) {
+            const isEthIdentity = (0, utils_1.isEthereumIdentity)(issuerDID);
+            if (!isEthIdentity && !(0, utils_1.isGenesisState)(issuerDID, currentStateBigInt)) {
                 throw new Error(`latest state not found and state parameter ${stateHex} is not genesis state`);
             }
+            if (isEthIdentity) {
+                throw new Error(`State must be published for Ethereum based identity`);
+            }
             latestState = currentStateBigInt;
         }
         const rhsHost = credentialStatus.id.split('/node')[0];

package/dist/node/cjs/iden3comm/handlers/auth.js

@@ -32,6 +32,7 @@ const uuid = __importStar(require("uuid"));
 const utils_1 = require("../../utils");
 const common_1 = require("./common");
 const circuits_1 = require("../../circuits");
+const message_handler_1 = require("./message-handler");
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
@@ -78,7 +79,7 @@ exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMe
  * @class AuthHandler
  * @implements implements IAuthHandler interface
  */
-class AuthHandler {
+class AuthHandler extends message_handler_1.AbstractMessageHandler {
     /**
      * Creates an instance of AuthHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -86,6 +87,7 @@ class AuthHandler {
      *
      */
     constructor(_packerMgr, _proofService) {
+        super();
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
         this._supportedCircuits = [
@@ -95,6 +97,16 @@ class AuthHandler {
             circuits_1.CircuitId.LinkedMultiQuery10
         ];
     }
+    handle(message, ctx) {
+        switch (message.type) {
+            case constants_2.PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE:
+                return this.handleAuthRequest(message, ctx);
+            case constants_2.PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE:
+                return this.handleAuthResponse(message, ctx);
+            default:
+                return super.handle(message, ctx);
+        }
+    }
     /**
      * @inheritdoc IAuthHandler#parseAuthorizationRequest
      */
@@ -107,44 +119,49 @@ class AuthHandler {
         authRequest.body.scope = authRequest.body.scope || [];
         return authRequest;
     }
-    /**
-     * @inheritdoc IAuthHandler#handleAuthorizationRequest
-     */
-    async handleAuthorizationRequest(did, request, opts) {
-        const authRequest = await this.parseAuthorizationRequest(request);
+    async handleAuthRequest(authRequest, ctx) {
         if (authRequest.type !== constants_2.PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE) {
             throw new Error('Invalid message type for authorization request');
         }
-        if (!opts) {
-            opts = {
-                mediaType: constants_1.MediaType.ZKPMessage
-            };
-        }
-        if (opts.mediaType === constants_1.MediaType.SignedMessage && !opts.packerOptions) {
-            throw new Error(`jws packer options are required for ${constants_1.MediaType.SignedMessage}`);
-        }
-        if (authRequest.to) {
-            // override sender did if it's explicitly specified in the auth request
-            did = js_iden3_core_1.DID.parse(authRequest.to);
-        }
+        // override sender did if it's explicitly specified in the auth request
+        const to = authRequest.to ? js_iden3_core_1.DID.parse(authRequest.to) : ctx.senderDid;
+        const mediaType = ctx.mediaType || constants_1.MediaType.ZKPMessage;
         const guid = uuid.v4();
         if (!authRequest.from) {
             throw new Error('auth request should contain from field');
         }
         const from = js_iden3_core_1.DID.parse(authRequest.from);
-        const responseScope = await (0, common_1.processZeroKnowledgeProofRequests)(did, authRequest?.body.scope, from, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
-        const authResponse = {
+        const responseScope = await (0, common_1.processZeroKnowledgeProofRequests)(to, authRequest?.body.scope, from, this._proofService, { mediaType, supportedCircuits: this._supportedCircuits });
+        return {
             id: guid,
-            typ: opts.mediaType,
+            typ: ctx.mediaType,
             type: constants_2.PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE,
             thid: authRequest.thid ?? guid,
             body: {
                 message: authRequest?.body?.message,
                 scope: responseScope
             },
-            from: did.string(),
+            from: to.string(),
             to: authRequest.from
         };
+    }
+    /**
+     * @inheritdoc IAuthHandler#handleAuthorizationRequest
+     */
+    async handleAuthorizationRequest(did, request, opts) {
+        const authRequest = await this.parseAuthorizationRequest(request);
+        if (!opts) {
+            opts = {
+                mediaType: constants_1.MediaType.ZKPMessage
+            };
+        }
+        if (opts.mediaType === constants_1.MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${constants_1.MediaType.SignedMessage}`);
+        }
+        const authResponse = await this.handleAuthRequest(authRequest, {
+            senderDid: did,
+            mediaType: opts.mediaType
+        });
         const msgBytes = utils_1.byteEncoder.encode(JSON.stringify(authResponse));
         const packerOpts = opts.mediaType === constants_1.MediaType.SignedMessage
             ? opts.packerOptions
@@ -157,10 +174,11 @@ class AuthHandler {
         }));
         return { authRequest, authResponse, token };
     }
-    /**
-     * @inheritdoc IAuthHandler#handleAuthorizationResponse
-     */
-    async handleAuthorizationResponse(response, request, opts) {
+    async handleAuthResponse(response, ctx) {
+        const request = ctx.request;
+        if (response.type !== constants_2.PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE) {
+            throw new Error('Invalid message type for authorization response');
+        }
         if ((request.body.message ?? '') !== (response.body.message ?? '')) {
             throw new Error('message for signing from request is not presented in response');
         }
@@ -187,6 +205,12 @@ class AuthHandler {
             }
             const params = proofRequest.params ?? {};
             params.verifierDid = js_iden3_core_1.DID.parse(request.from);
+            const opts = [ctx.acceptedProofGenerationDelay, ctx.acceptedStateTransitionDelay].some((delay) => delay !== undefined)
+                ? {
+                    acceptedProofGenerationDelay: ctx.acceptedProofGenerationDelay,
+                    acceptedStateTransitionDelay: ctx.acceptedStateTransitionDelay
+                }
+                : undefined;
             const { linkID } = await this._proofService.verifyZKPResponse(proofResp, {
                 query: proofRequest.query,
                 sender: response.from,
@@ -209,7 +233,18 @@ class AuthHandler {
                 throw new Error(`Link id validation failed for group ${groupId}, request linkID to requestIds info: ${JSON.stringify(metas)}`);
             }
         }
-        return { request, response };
+        return response;
+    }
+    /**
+     * @inheritdoc IAuthHandler#handleAuthorizationResponse
+     */
+    async handleAuthorizationResponse(response, request, opts) {
+        const authResp = (await this.handleAuthResponse(response, {
+            request,
+            acceptedStateTransitionDelay: opts?.acceptedStateTransitionDelay,
+            acceptedProofGenerationDelay: opts?.acceptedProofGenerationDelay
+        }));
+        return { request, response: authResp };
     }
     verifyAuthRequest(request) {
         const groupIdValidationMap = {};

package/dist/node/cjs/iden3comm/handlers/common.js

@@ -37,14 +37,14 @@ const getGroupedQueries = (requestScope) => requestScope.reduce((acc, proofReq)
 /**
  * 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.
  */
-const processZeroKnowledgeProofRequests = async (senderIdentifier, requests, from, proofService, opts) => {
+const processZeroKnowledgeProofRequests = async (to, requests, from, proofService, opts) => {
     const requestScope = requests ?? [];
     const combinedQueries = getGroupedQueries(requestScope);
     const groupedCredentialsCache = new Map();
@@ -62,7 +62,7 @@ const processZeroKnowledgeProofRequests = async (senderIdentifier, requests, fro
             }
             const combinedQuery = combinedQueryData.query;
             if (!groupedCredentialsCache.has(groupId)) {
-                const credWithRevStatus = await proofService.findCredentialByProofQuery(senderIdentifier, combinedQueryData.query);
+                const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
                 if (!credWithRevStatus.cred) {
                     throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
                 }
@@ -70,7 +70,7 @@ const processZeroKnowledgeProofRequests = async (senderIdentifier, requests, fro
             }
         }
         const credWithRevStatus = groupedCredentialsCache.get(groupId);
-        const zkpRes = await proofService.generateProof(proofReq, senderIdentifier, {
+        const zkpRes = await proofService.generateProof(proofReq, to, {
             verifierDid: from,
             challenge: opts.challenge,
             skipRevocation: Boolean(query.skipClaimRevocationCheck),

package/dist/node/cjs/iden3comm/handlers/contract-request.js

@@ -5,6 +5,7 @@ const models_1 = require("../../circuits/models");
 const constants_1 = require("../constants");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const common_1 = require("./common");
+const message_handler_1 = require("./message-handler");
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -14,7 +15,7 @@ const common_1 = require("./common");
  * @class ContractRequestHandler
  * @implements implements IContractRequestHandler interface
  */
-class ContractRequestHandler {
+class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
     /**
      * Creates an instance of ContractRequestHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -23,6 +24,7 @@ class ContractRequestHandler {
      *
      */
     constructor(_packerMgr, _proofService, _zkpVerifier) {
+        super();
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
         this._zkpVerifier = _zkpVerifier;
@@ -32,6 +34,32 @@ class ContractRequestHandler {
             models_1.CircuitId.AtomicQueryV3OnChain
         ];
     }
+    async handle(message, ctx) {
+        switch (message.type) {
+            case constants_1.PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE:
+                await this.handleContractInvoke(message, ctx);
+                return null;
+            default:
+                return super.handle(message, ctx);
+        }
+    }
+    async handleContractInvoke(message, ctx) {
+        if (message.type !== constants_1.PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
+            throw new Error('Invalid message type for contract invoke request');
+        }
+        const { senderDid: did, ethSigner, challenge } = ctx;
+        if (!ctx.ethSigner) {
+            throw new Error("Can't sign transaction. Provide Signer in options.");
+        }
+        const { chain_id } = message.body.transaction_data;
+        const networkFlag = Object.keys(js_iden3_core_1.ChainIds).find((key) => js_iden3_core_1.ChainIds[key] === chain_id);
+        if (!networkFlag) {
+            throw new Error(`Invalid chain id ${chain_id}`);
+        }
+        const verifierDid = message.from ? js_iden3_core_1.DID.parse(message.from) : undefined;
+        const zkpResponses = await (0, common_1.processZeroKnowledgeProofRequests)(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+        return this._zkpVerifier.submitZKPResponse(ethSigner, message.body.transaction_data, zkpResponses);
+    }
     /**
      * unpacks contract-invoke request
      * @beta
@@ -57,20 +85,11 @@ class ContractRequestHandler {
      */
     async handleContractInvokeRequest(did, request, opts) {
         const ciRequest = await this.parseContractInvokeRequest(request);
-        if (ciRequest.type !== constants_1.PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
-            throw new Error('Invalid message type for contract invoke request');
-        }
-        if (!opts.ethSigner) {
-            throw new Error("Can't sign transaction. Provide Signer in options.");
-        }
-        const { chain_id } = ciRequest.body.transaction_data;
-        const networkFlag = Object.keys(js_iden3_core_1.ChainIds).find((key) => js_iden3_core_1.ChainIds[key] === chain_id);
-        if (!networkFlag) {
-            throw new Error(`Invalid chain id ${chain_id}`);
-        }
-        const verifierDid = ciRequest.from ? js_iden3_core_1.DID.parse(ciRequest.from) : undefined;
-        const zkpResponses = await (0, common_1.processZeroKnowledgeProofRequests)(did, ciRequest?.body?.scope, verifierDid, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
-        return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkpResponses);
+        return this.handleContractInvoke(ciRequest, {
+            senderDid: did,
+            ethSigner: opts.ethSigner,
+            challenge: opts.challenge
+        });
     }
 }
 exports.ContractRequestHandler = ContractRequestHandler;

package/dist/node/cjs/iden3comm/handlers/credential-proposal.js

@@ -30,6 +30,7 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const uuid = __importStar(require("uuid"));
 const js_jwz_1 = require("@iden3/js-jwz");
 const utils_1 = require("../../utils");
+const message_handler_1 = require("./message-handler");
 /**
  * @beta
  * createProposalRequest is a function to create protocol proposal-request protocol message
@@ -83,7 +84,7 @@ exports.createProposal = createProposal;
  * @class CredentialProposalHandler
  * @implements implements ICredentialProposalHandler interface
  */
-class CredentialProposalHandler {
+class CredentialProposalHandler extends message_handler_1.AbstractMessageHandler {
     /**
      * @beta Creates an instance of CredentialProposalHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -92,10 +93,19 @@ class CredentialProposalHandler {
      *
      */
     constructor(_packerMgr, _identityWallet, _params) {
+        super();
         this._packerMgr = _packerMgr;
         this._identityWallet = _identityWallet;
         this._params = _params;
     }
+    async handle(message, context) {
+        switch (message.type) {
+            case constants_1.PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE:
+                return (await this.handleProposalRequestMessage(message, context));
+            default:
+                return super.handle(message, context);
+        }
+    }
     /**
      * @inheritdoc ICredentialProposalHandler#parseProposalRequest
      */
@@ -107,17 +117,9 @@ class CredentialProposalHandler {
         }
         return proposalRequest;
     }
-    /**
-     * @inheritdoc ICredentialProposalHandler#handleProposalRequest
-     */
-    async handleProposalRequest(request, 
-    //eslint-disable-next-line @typescript-eslint/no-unused-vars
-    opts) {
-        if (this._params.packerParams.mediaType === constants_2.MediaType.SignedMessage &&
-            !this._params.packerParams.packerOptions) {
-            throw new Error(`jws packer options are required for ${constants_2.MediaType.SignedMessage}`);
-        }
-        const proposalRequest = await this.parseProposalRequest(request);
+    async handleProposalRequestMessage(proposalRequest, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ctx) {
         if (!proposalRequest.to) {
             throw new Error(`failed request. empty 'to' field`);
         }
@@ -188,8 +190,25 @@ class CredentialProposalHandler {
             }
             proposalMessage.body?.proposals.push(proposal);
         }
-        // if there is credentials in the wallet, return offer protocol message, otherwise proposal
-        const response = utils_1.byteEncoder.encode(JSON.stringify(proposalMessage ?? credOfferMessage));
+        return proposalMessage ?? credOfferMessage;
+    }
+    /**
+     * @inheritdoc ICredentialProposalHandler#handleProposalRequest
+     */
+    async handleProposalRequest(request, 
+    //eslint-disable-next-line @typescript-eslint/no-unused-vars
+    opts) {
+        if (this._params.packerParams.mediaType === constants_2.MediaType.SignedMessage &&
+            !this._params.packerParams.packerOptions) {
+            throw new Error(`jws packer options are required for ${constants_2.MediaType.SignedMessage}`);
+        }
+        const proposalRequest = await this.parseProposalRequest(request);
+        if (!proposalRequest.from) {
+            throw new Error(`failed request. empty 'from' field`);
+        }
+        const senderDID = js_iden3_core_1.DID.parse(proposalRequest.from);
+        const message = await this.handleProposalRequestMessage(proposalRequest);
+        const response = utils_1.byteEncoder.encode(JSON.stringify(message));
         const packerOpts = this._params.packerParams.mediaType === constants_2.MediaType.SignedMessage
             ? this._params.packerParams.packerOptions
             : {

package/dist/node/cjs/iden3comm/handlers/fetch.js

@@ -32,6 +32,7 @@ const utils_1 = require("../../utils");
 const js_jwz_1 = require("@iden3/js-jwz");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const uuid = __importStar(require("uuid"));
+const message_handler_1 = require("./message-handler");
 /**
  *
  * Allows to handle Credential offer protocol message and return fetched credential
@@ -41,41 +42,43 @@ const uuid = __importStar(require("uuid"));
  * @class FetchHandler
  * @implements implements IFetchHandler interface
  */
-class FetchHandler {
+class FetchHandler extends message_handler_1.AbstractMessageHandler {
     /**
-     * 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, opts) {
+        super();
         this._packerMgr = _packerMgr;
         this.opts = opts;
     }
-    /**
-     * Handles only messages with credentials/1.0/offer type
-     *
-     * @param {
-     *     offer: Uint8Array; offer - raw offer message
-     *     opts
-     *   }) options how to fetch credential
-     * @returns `Promise<W3CCredential[]>`
-     */
-    async handleCredentialOffer(offer, opts) {
-        if (!opts) {
-            opts = {
-                mediaType: constants_1.MediaType.ZKPMessage
-            };
+    async handle(message, ctx) {
+        switch (message.type) {
+            case constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE:
+                await this.handleOfferMessage(message, ctx);
+                return null;
+            case constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE:
+                return this.handleFetchRequest(message);
+            case constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE:
+                return this.handleIssuanceResponseMsg(message);
+            default:
+                return super.handle(message, ctx);
         }
-        if (opts.mediaType === constants_1.MediaType.SignedMessage && !opts.packerOptions) {
-            throw new Error(`jws packer options are required for ${constants_1.MediaType.SignedMessage}`);
+    }
+    async handleOfferMessage(offerMessage, ctx) {
+        if (!ctx.mediaType) {
+            ctx.mediaType = constants_1.MediaType.ZKPMessage;
         }
-        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE);
         const credentials = [];
         for (let index = 0; index < offerMessage.body.credentials.length; index++) {
             const credentialInfo = offerMessage.body.credentials[index];
             const guid = uuid.v4();
             const fetchRequest = {
                 id: guid,
-                typ: opts.mediaType,
+                typ: ctx.mediaType,
                 type: constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE,
                 thid: offerMessage.thid ?? guid,
                 body: {
@@ -85,13 +88,13 @@ class FetchHandler {
                 to: offerMessage.from
             };
             const msgBytes = utils_1.byteEncoder.encode(JSON.stringify(fetchRequest));
-            const packerOpts = opts.mediaType === constants_1.MediaType.SignedMessage
-                ? opts.packerOptions
+            const packerOpts = ctx.mediaType === constants_1.MediaType.SignedMessage
+                ? ctx.packerOptions
                 : {
                     provingMethodAlg: js_jwz_1.proving.provingMethodGroth16AuthV2Instance.methodAlg
                 };
             const senderDID = js_iden3_core_1.DID.parse(offerMessage.to);
-            const token = utils_1.byteDecoder.decode(await this._packerMgr.pack(opts.mediaType, msgBytes, {
+            const token = utils_1.byteDecoder.decode(await this._packerMgr.pack(ctx.mediaType, msgBytes, {
                 senderDID,
                 ...packerOpts
             }));
@@ -104,7 +107,7 @@ class FetchHandler {
                     method: 'post',
                     headers: {
                         'Content-Type': 'application/x-www-form-urlencoded',
-                        ...(opts.headers ?? {})
+                        ...ctx.headers
                     },
                     body: token
                 });
@@ -121,10 +124,26 @@ class FetchHandler {
         return credentials;
     }
     /**
-     * @inheritdoc IFetchHandler#handleCredentialFetchRequest
+     * Handles only messages with credentials/1.0/offer type
+     *
+     * @param {
+     *     offer: Uint8Array; offer - raw offer message
+     *     opts
+     *   }) options how to fetch credential
+     * @returns `Promise<W3CCredential[]>`
      */
-    async handleCredentialFetchRequest(envelope) {
-        const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+    async handleCredentialOffer(offer, opts) {
+        if (opts?.mediaType === constants_1.MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${constants_1.MediaType.SignedMessage}`);
+        }
+        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE);
+        return this.handleOfferMessage(offerMessage, {
+            mediaType: opts?.mediaType,
+            headers: opts?.headers,
+            packerOptions: opts?.packerOptions
+        });
+    }
+    async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
             throw new Error("failed request. empty 'to' field");
         }
@@ -148,7 +167,7 @@ class FetchHandler {
         if (userToVerifyDID.string() !== userDID.string()) {
             throw new Error('credential subject is not a sender DID');
         }
-        return this._packerMgr.pack(constants_1.MediaType.PlainMessage, utils_1.byteEncoder.encode(JSON.stringify({
+        return {
             id: uuid.v4(),
             type: constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE,
             typ: msgRequest.typ ?? constants_1.MediaType.PlainMessage,
@@ -156,13 +175,17 @@ class FetchHandler {
             body: { credential: cred },
             from: msgRequest.to,
             to: msgRequest.from
-        })), {});
+        };
     }
     /**
-     * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
+     * @inheritdoc IFetchHandler#handleCredentialFetchRequest
      */
-    async handleIssuanceResponseMessage(envelop) {
-        const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+    async handleCredentialFetchRequest(envelope) {
+        const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+        const request = await this.handleFetchRequest(msgRequest);
+        return this._packerMgr.pack(constants_1.MediaType.PlainMessage, utils_1.byteEncoder.encode(JSON.stringify(request)), {});
+    }
+    async handleIssuanceResponseMsg(issuanceMsg) {
         if (!this.opts?.credentialWallet) {
             throw new Error('please provide credential wallet in options');
         }
@@ -170,7 +193,15 @@ class FetchHandler {
             throw new Error('credential is missing in issuance response message');
         }
         await this.opts.credentialWallet.save(verifiable_1.W3CCredential.fromJSON(issuanceMsg.body.credential));
-        return Promise.resolve(Uint8Array.from([]));
+        return null;
+    }
+    /**
+     * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
+     */
+    async handleIssuanceResponseMessage(envelop) {
+        const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+        await this.handleIssuanceResponseMsg(issuanceMsg);
+        return Uint8Array.from([]);
     }
     /**
      * @inheritdoc IFetchHandler#unpackMessage

package/dist/node/cjs/iden3comm/handlers/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./refresh"), exports);
 __exportStar(require("./revocation-status"), exports);
 __exportStar(require("./common"), exports);
 __exportStar(require("./credential-proposal"), exports);
+__exportStar(require("./message-handler"), exports);