@0xpolygonid/js-sdk 1.12.0 → 1.14.0

package/dist/node/cjs/iden3comm/constants.js

@@ -39,7 +39,11 @@ exports.PROTOCOL_MESSAGE_TYPE = Object.freeze({
     // ProposalRequestMessageType is type for proposal-request message
     PROPOSAL_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal-request',
     // ProposalMessageType is type for proposal message
-    PROPOSAL_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal'
+    PROPOSAL_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal',
+    // PaymentRequestMessageType is type for payment-request message
+    PAYMENT_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/payment-request',
+    // PaymentMessageType is type for payment message
+    PAYMENT_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/payment'
 });
 /**
  * Media types for iden3 comm communication protocol

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

@@ -57,9 +57,17 @@ class FetchHandler extends message_handler_1.AbstractMessageHandler {
     }
     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_OFFER_MESSAGE_TYPE: {
+                const result = await this.handleOfferMessage(message, ctx);
+                if (Array.isArray(result)) {
+                    const credWallet = this.opts?.credentialWallet;
+                    if (!credWallet)
+                        throw new Error('Credential wallet is not provided');
+                    await credWallet.saveAll(result);
+                    return null;
+                }
+                return result;
+            }
             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:
@@ -73,8 +81,7 @@ class FetchHandler extends message_handler_1.AbstractMessageHandler {
             ctx.mediaType = constants_1.MediaType.ZKPMessage;
         }
         const credentials = [];
-        for (let index = 0; index < offerMessage.body.credentials.length; index++) {
-            const credentialInfo = offerMessage.body.credentials[index];
+        for (const credentialInfo of offerMessage.body.credentials) {
             const guid = uuid.v4();
             const fetchRequest = {
                 id: guid,
@@ -98,7 +105,6 @@ class FetchHandler extends message_handler_1.AbstractMessageHandler {
                 senderDID,
                 ...packerOpts
             }));
-            let message;
             try {
                 if (!offerMessage?.body?.url) {
                     throw new Error(`could not fetch W3C credential, body url is missing`);
@@ -111,14 +117,18 @@ class FetchHandler extends message_handler_1.AbstractMessageHandler {
                     },
                     body: token
                 });
-                if (resp.status !== 200) {
-                    throw new Error(`could not fetch W3C credential, ${credentialInfo?.id}`);
+                const arrayBuffer = await resp.arrayBuffer();
+                if (!arrayBuffer.byteLength) {
+                    throw new Error(`could not fetch , ${credentialInfo?.id}, response is empty`);
+                }
+                const { unpackedMessage: message } = await this._packerMgr.unpack(new Uint8Array(arrayBuffer));
+                if (message.type !== constants_2.PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE) {
+                    return message;
                 }
-                message = await resp.json();
                 credentials.push(verifiable_1.W3CCredential.fromJSON(message.body.credential));
             }
             catch (e) {
-                throw new Error(`could not fetch W3C credential, ${credentialInfo?.id}, error: ${e.message ?? e}`);
+                throw new Error(`could not fetch protocol message for credential offer id: , ${credentialInfo?.id}, error: ${e.message ?? e}`);
             }
         }
         return credentials;
@@ -137,11 +147,15 @@ class FetchHandler extends message_handler_1.AbstractMessageHandler {
             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, {
+        const result = await this.handleOfferMessage(offerMessage, {
             mediaType: opts?.mediaType,
             headers: opts?.headers,
             packerOptions: opts?.packerOptions
         });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        throw new Error('invalid protocol message response');
     }
     async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
@@ -154,7 +168,7 @@ class FetchHandler extends message_handler_1.AbstractMessageHandler {
         const userDID = js_iden3_core_1.DID.parse(msgRequest.from);
         const credId = msgRequest.body?.id;
         if (!credId) {
-            throw new Error('nvalid credential id in fetch request body');
+            throw new Error('invalid credential id in fetch request body');
         }
         if (!this.opts?.credentialWallet) {
             throw new Error('please, provide credential wallet in options');

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

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

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

@@ -0,0 +1,232 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentHandler = exports.createPayment = exports.createPaymentRequest = void 0;
+const constants_1 = require("../constants");
+const constants_2 = require("../constants");
+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");
+const verifiable_1 = require("../../verifiable");
+/**
+ * @beta
+ * createPaymentRequest is a function to create protocol payment-request message
+ * @param {DID} sender - sender did
+ * @param {DID} receiver - receiver did
+ * @param {string} agent - agent URL
+ * @param {PaymentRequestInfo[]} payments - payments
+ * @returns `PaymentRequestMessage`
+ */
+function createPaymentRequest(sender, receiver, agent, payments) {
+    const uuidv4 = uuid.v4();
+    const request = {
+        id: uuidv4,
+        thid: uuidv4,
+        from: sender.string(),
+        to: receiver.string(),
+        typ: constants_2.MediaType.PlainMessage,
+        type: constants_1.PROTOCOL_MESSAGE_TYPE.PAYMENT_REQUEST_MESSAGE_TYPE,
+        body: {
+            agent,
+            payments
+        }
+    };
+    return request;
+}
+exports.createPaymentRequest = createPaymentRequest;
+/**
+ * @beta
+ * createPayment is a function to create protocol payment message
+ * @param {DID} sender - sender did
+ * @param {DID} receiver - receiver did
+ * @param {PaymentInfo[]} payments - payments
+ * @returns `PaymentMessage`
+ */
+function createPayment(sender, receiver, payments) {
+    const uuidv4 = uuid.v4();
+    const request = {
+        id: uuidv4,
+        thid: uuidv4,
+        from: sender.string(),
+        to: receiver.string(),
+        typ: constants_2.MediaType.PlainMessage,
+        type: constants_1.PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE,
+        body: {
+            payments
+        }
+    };
+    return request;
+}
+exports.createPayment = createPayment;
+/**
+ *
+ * Allows to process PaymentRequest protocol message
+ * @beta
+ * @class PaymentHandler
+ * @implements implements IPaymentHandler interface
+ */
+class PaymentHandler extends message_handler_1.AbstractMessageHandler {
+    /**
+     * @beta Creates an instance of PaymentHandler.
+     * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+     * @param {PaymentHandlerParams} _params - payment handler params
+     *
+     */
+    constructor(_packerMgr, _params) {
+        super();
+        this._packerMgr = _packerMgr;
+        this._params = _params;
+    }
+    async handle(message, context) {
+        switch (message.type) {
+            case constants_1.PROTOCOL_MESSAGE_TYPE.PAYMENT_REQUEST_MESSAGE_TYPE:
+                return await this.handlePaymentRequestMessage(message, context);
+            case constants_1.PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE:
+                await this.handlePayment(message, context);
+                return null;
+            default:
+                return super.handle(message, context);
+        }
+    }
+    /**
+     * @inheritdoc IPaymentHandler#parsePaymentRequest
+     */
+    async parsePaymentRequest(request) {
+        const { unpackedMessage: message } = await this._packerMgr.unpack(request);
+        const paymentRequest = message;
+        if (message.type !== constants_1.PROTOCOL_MESSAGE_TYPE.PAYMENT_REQUEST_MESSAGE_TYPE) {
+            throw new Error('Invalid media type');
+        }
+        return paymentRequest;
+    }
+    async handlePaymentRequestMessage(paymentRequest, ctx) {
+        if (!paymentRequest.to) {
+            throw new Error(`failed request. empty 'to' field`);
+        }
+        if (!paymentRequest.from) {
+            throw new Error(`failed request. empty 'from' field`);
+        }
+        if (!paymentRequest.body?.payments?.length) {
+            throw new Error(`failed request. no 'payments' in body`);
+        }
+        if (!ctx.paymentHandler) {
+            throw new Error(`please provide payment handler in context`);
+        }
+        const senderDID = js_iden3_core_1.DID.parse(paymentRequest.to);
+        const receiverDID = js_iden3_core_1.DID.parse(paymentRequest.from);
+        const payments = [];
+        for (let i = 0; i < paymentRequest.body.payments.length; i++) {
+            const paymentReq = paymentRequest.body.payments[i];
+            if (paymentReq.type !== verifiable_1.PaymentRequestType.PaymentRequest) {
+                throw new Error(`failed request. not supported '${paymentReq.type}' payment type `);
+            }
+            if (paymentReq.data.type !== verifiable_1.PaymentRequestDataType.Iden3PaymentRequestCryptoV1) {
+                throw new Error(`failed request. not supported '${paymentReq.data.type}' payment type `);
+            }
+            const txId = await ctx.paymentHandler(paymentReq.data);
+            payments.push({
+                id: paymentReq.data.id,
+                type: verifiable_1.PaymentType.Iden3PaymentCryptoV1,
+                paymentData: {
+                    txId
+                }
+            });
+        }
+        const paymentMessage = createPayment(senderDID, receiverDID, payments);
+        const response = await this.packMessage(paymentMessage, senderDID);
+        const agentResult = await fetch(paymentRequest.body.agent, {
+            method: 'POST',
+            body: response,
+            headers: {
+                'Content-Type': 'application/octet-stream'
+            }
+        });
+        const arrayBuffer = await agentResult.arrayBuffer();
+        if (!arrayBuffer.byteLength) {
+            return null;
+        }
+        const { unpackedMessage } = await this._packerMgr.unpack(new Uint8Array(arrayBuffer));
+        return unpackedMessage;
+    }
+    /**
+     * @inheritdoc IPaymentHandler#handlePaymentRequest
+     */
+    async handlePaymentRequest(request, 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 paymentRequest = await this.parsePaymentRequest(request);
+        if (!paymentRequest.from) {
+            throw new Error(`failed request. empty 'from' field`);
+        }
+        if (!paymentRequest.to) {
+            throw new Error(`failed request. empty 'to' field`);
+        }
+        const agentMessage = await this.handlePaymentRequestMessage(paymentRequest, opts);
+        if (!agentMessage) {
+            return null;
+        }
+        const senderDID = js_iden3_core_1.DID.parse(paymentRequest.to);
+        return this.packMessage(agentMessage, senderDID);
+    }
+    /**
+     * @inheritdoc IPaymentHandler#handlePayment
+     */
+    async handlePayment(payment, opts) {
+        if (opts.paymentRequest.from !== payment.to) {
+            throw new Error(`sender of the request is not a target of response - expected ${opts.paymentRequest.from}, given ${payment.to}`);
+        }
+        if (!payment.body?.payments.length) {
+            throw new Error(`failed request. empty 'payments' field in body`);
+        }
+        for (let i = 0; i < payment.body.payments.length; i++) {
+            const p = payment.body?.payments[i];
+            const paymentRequestData = opts.paymentRequest.body?.payments.find((r) => r.data.id === p.id);
+            if (!paymentRequestData) {
+                throw new Error(`can't find payment request for payment id ${p.id}`);
+            }
+            if (!opts.paymentValidationHandler) {
+                throw new Error(`please provide payment validation handler in options`);
+            }
+            await opts.paymentValidationHandler(p.paymentData.txId, paymentRequestData.data);
+        }
+    }
+    async packMessage(message, senderDID) {
+        const responseEncoded = utils_1.byteEncoder.encode(JSON.stringify(message));
+        const packerOpts = this._params.packerParams.mediaType === constants_2.MediaType.SignedMessage
+            ? this._params.packerParams.packerOptions
+            : {
+                provingMethodAlg: js_jwz_1.proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        return await this._packerMgr.pack(this._params.packerParams.mediaType, responseEncoded, {
+            senderDID,
+            ...packerOpts
+        });
+    }
+}
+exports.PaymentHandler = PaymentHandler;

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

@@ -21,5 +21,6 @@ __exportStar(require("./protocol/proof"), exports);
 __exportStar(require("./protocol/revocation"), exports);
 __exportStar(require("./protocol/contract-request"), exports);
 __exportStar(require("./protocol/proposal-request"), exports);
+__exportStar(require("./protocol/payment"), exports);
 __exportStar(require("./packer"), exports);
 __exportStar(require("./packageManager"), exports);

package/dist/node/cjs/iden3comm/types/protocol/payment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/cjs/proof/common.js

@@ -129,10 +129,23 @@ const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType,
         if (!(0, circuits_1.isValidOperation)(query.datatype, propertyQuery.operator)) {
             throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${query.datatype}`);
         }
-        query.values =
-            propertyQuery.operator === circuits_1.Operators.EXISTS
-                ? transformExistsValue(propertyQuery.operatorValue)
-                : await (0, exports.transformQueryValueToBigInts)(propertyQuery.operatorValue, query.datatype);
+        if ((propertyQuery.operator === circuits_1.Operators.NOOP || propertyQuery.operator === circuits_1.Operators.SD) &&
+            propertyQuery.operatorValue) {
+            throw new Error(`operator value should be undefined for ${propertyQuery.operator} operator`);
+        }
+        let values;
+        switch (propertyQuery.operator) {
+            case circuits_1.Operators.NOOP:
+            case circuits_1.Operators.SD:
+                values = [];
+                break;
+            case circuits_1.Operators.EXISTS:
+                values = transformExistsValue(propertyQuery.operatorValue);
+                break;
+            default:
+                values = await (0, exports.transformQueryValueToBigInts)(propertyQuery.operatorValue, query.datatype);
+        }
+        query.values = values;
     }
     return query;
 };

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
+exports.SupportedCurrencies = exports.PaymentType = exports.PaymentRequestDataType = exports.PaymentRequestType = exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
 /** Verifiable constants */
 exports.VerifiableConstants = Object.freeze({
     ERRORS: {
@@ -113,3 +113,39 @@ var RefreshServiceType;
 (function (RefreshServiceType) {
     RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
 })(RefreshServiceType = exports.RefreshServiceType || (exports.RefreshServiceType = {}));
+/**
+ * PaymentRequestType type for payment requests
+ * @beta
+ * @enum {string}
+ */
+var PaymentRequestType;
+(function (PaymentRequestType) {
+    PaymentRequestType["PaymentRequest"] = "PaymentRequest";
+})(PaymentRequestType = exports.PaymentRequestType || (exports.PaymentRequestType = {}));
+/**
+ * PaymentRequestDataType type for payment requests
+ * @beta
+ * @enum {string}
+ */
+var PaymentRequestDataType;
+(function (PaymentRequestDataType) {
+    PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+})(PaymentRequestDataType = exports.PaymentRequestDataType || (exports.PaymentRequestDataType = {}));
+/**
+ * PaymentType type for payment responses
+ * @beta
+ * @enum {string}
+ */
+var PaymentType;
+(function (PaymentType) {
+    PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+})(PaymentType = exports.PaymentType || (exports.PaymentType = {}));
+/**
+ * Media types for Payment supported currencies
+ * @beta
+ * @enum {number}
+ */
+var SupportedCurrencies;
+(function (SupportedCurrencies) {
+    SupportedCurrencies["ETH"] = "ETH";
+})(SupportedCurrencies = exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));

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

@@ -36,7 +36,11 @@ export const PROTOCOL_MESSAGE_TYPE = Object.freeze({
     // ProposalRequestMessageType is type for proposal-request message
     PROPOSAL_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal-request',
     // ProposalMessageType is type for proposal message
-    PROPOSAL_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal'
+    PROPOSAL_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/proposal',
+    // PaymentRequestMessageType is type for payment-request message
+    PAYMENT_REQUEST_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/payment-request',
+    // PaymentMessageType is type for payment message
+    PAYMENT_MESSAGE_TYPE: IDEN3_PROTOCOL + 'credentials/0.1/payment'
 });
 /**
  * Media types for iden3 comm communication protocol

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

@@ -31,9 +31,17 @@ export class FetchHandler extends AbstractMessageHandler {
     }
     async handle(message, ctx) {
         switch (message.type) {
-            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE:
-                await this.handleOfferMessage(message, ctx);
-                return null;
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE: {
+                const result = await this.handleOfferMessage(message, ctx);
+                if (Array.isArray(result)) {
+                    const credWallet = this.opts?.credentialWallet;
+                    if (!credWallet)
+                        throw new Error('Credential wallet is not provided');
+                    await credWallet.saveAll(result);
+                    return null;
+                }
+                return result;
+            }
             case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE:
                 return this.handleFetchRequest(message);
             case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE:
@@ -47,8 +55,7 @@ export class FetchHandler extends AbstractMessageHandler {
             ctx.mediaType = MediaType.ZKPMessage;
         }
         const credentials = [];
-        for (let index = 0; index < offerMessage.body.credentials.length; index++) {
-            const credentialInfo = offerMessage.body.credentials[index];
+        for (const credentialInfo of offerMessage.body.credentials) {
             const guid = uuid.v4();
             const fetchRequest = {
                 id: guid,
@@ -72,7 +79,6 @@ export class FetchHandler extends AbstractMessageHandler {
                 senderDID,
                 ...packerOpts
             }));
-            let message;
             try {
                 if (!offerMessage?.body?.url) {
                     throw new Error(`could not fetch W3C credential, body url is missing`);
@@ -85,14 +91,18 @@ export class FetchHandler extends AbstractMessageHandler {
                     },
                     body: token
                 });
-                if (resp.status !== 200) {
-                    throw new Error(`could not fetch W3C credential, ${credentialInfo?.id}`);
+                const arrayBuffer = await resp.arrayBuffer();
+                if (!arrayBuffer.byteLength) {
+                    throw new Error(`could not fetch , ${credentialInfo?.id}, response is empty`);
+                }
+                const { unpackedMessage: message } = await this._packerMgr.unpack(new Uint8Array(arrayBuffer));
+                if (message.type !== PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE) {
+                    return message;
                 }
-                message = await resp.json();
                 credentials.push(W3CCredential.fromJSON(message.body.credential));
             }
             catch (e) {
-                throw new Error(`could not fetch W3C credential, ${credentialInfo?.id}, error: ${e.message ?? e}`);
+                throw new Error(`could not fetch protocol message for credential offer id: , ${credentialInfo?.id}, error: ${e.message ?? e}`);
             }
         }
         return credentials;
@@ -111,11 +121,15 @@ export class FetchHandler extends AbstractMessageHandler {
             throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
         }
         const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_OFFER_MESSAGE_TYPE);
-        return this.handleOfferMessage(offerMessage, {
+        const result = await this.handleOfferMessage(offerMessage, {
             mediaType: opts?.mediaType,
             headers: opts?.headers,
             packerOptions: opts?.packerOptions
         });
+        if (Array.isArray(result)) {
+            return result;
+        }
+        throw new Error('invalid protocol message response');
     }
     async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
@@ -128,7 +142,7 @@ export class FetchHandler extends AbstractMessageHandler {
         const userDID = DID.parse(msgRequest.from);
         const credId = msgRequest.body?.id;
         if (!credId) {
-            throw new Error('nvalid credential id in fetch request body');
+            throw new Error('invalid credential id in fetch request body');
         }
         if (!this.opts?.credentialWallet) {
             throw new Error('please, provide credential wallet in options');

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

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