@0xpolygonid/js-sdk 1.12.0 → 1.13.0

package/dist/browser/umd/index.js

@@ -7496,6 +7496,33 @@ var PolygonIdSdk = (function (exports) {
     (function (RefreshServiceType) {
         RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
     })(exports.RefreshServiceType || (exports.RefreshServiceType = {}));
+    /**
+     * PaymentRequestType type for payment requests
+     *
+     * @enum {string}
+     */
+    exports.PaymentRequestType = void 0;
+    (function (PaymentRequestType) {
+        PaymentRequestType["PaymentRequest"] = "PaymentRequest";
+    })(exports.PaymentRequestType || (exports.PaymentRequestType = {}));
+    /**
+     * PaymentRequestDataType type for payment requests
+     *
+     * @enum {string}
+     */
+    exports.PaymentRequestDataType = void 0;
+    (function (PaymentRequestDataType) {
+        PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+    })(exports.PaymentRequestDataType || (exports.PaymentRequestDataType = {}));
+    /**
+     * PaymentType type for payment responses
+     *
+     * @enum {string}
+     */
+    exports.PaymentType = void 0;
+    (function (PaymentType) {
+        PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+    })(exports.PaymentType || (exports.PaymentType = {}));
 
     /**
      * Iden3SparseMerkleProof is a iden3 protocol merkle tree proof
@@ -53622,7 +53649,11 @@ var PolygonIdSdk = (function (exports) {
         // 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
@@ -79046,6 +79077,202 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     * @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 = v4();
+        const request = {
+            id: uuidv4,
+            thid: uuidv4,
+            from: sender.string(),
+            to: receiver.string(),
+            typ: MediaType.PlainMessage,
+            type: PROTOCOL_MESSAGE_TYPE.PAYMENT_REQUEST_MESSAGE_TYPE,
+            body: {
+                agent,
+                payments
+            }
+        };
+        return request;
+    }
+    /**
+     * @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 = v4();
+        const request = {
+            id: uuidv4,
+            thid: uuidv4,
+            from: sender.string(),
+            to: receiver.string(),
+            typ: MediaType.PlainMessage,
+            type: PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE,
+            body: {
+                payments
+            }
+        };
+        return request;
+    }
+    /**
+     *
+     * Allows to process PaymentRequest protocol message
+     * @beta
+     * @class PaymentHandler
+     * @implements implements IPaymentHandler interface
+     */
+    class PaymentHandler extends 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 PROTOCOL_MESSAGE_TYPE.PAYMENT_REQUEST_MESSAGE_TYPE:
+                    return await this.handlePaymentRequestMessage(message, context);
+                case 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 !== 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 = Z$2.parse(paymentRequest.to);
+            const receiverDID = Z$2.parse(paymentRequest.from);
+            const payments = [];
+            for (let i = 0; i < paymentRequest.body.payments.length; i++) {
+                const paymentReq = paymentRequest.body.payments[i];
+                if (paymentReq.type !== exports.PaymentRequestType.PaymentRequest) {
+                    throw new Error(`failed request. not supported '${paymentReq.type}' payment type `);
+                }
+                if (paymentReq.data.type !== exports.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: exports.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 === MediaType.SignedMessage &&
+                !this._params.packerParams.packerOptions) {
+                throw new Error(`jws packer options are required for ${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 = Z$2.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 = byteEncoder.encode(JSON.stringify(message));
+            const packerOpts = this._params.packerParams.mediaType === MediaType.SignedMessage
+                ? this._params.packerParams.packerOptions
+                : {
+                    provingMethodAlg: T.provingMethodGroth16AuthV2Instance.methodAlg
+                };
+            return await this._packerMgr.pack(this._params.packerParams.mediaType, responseEncoded, {
+                senderDID,
+                ...packerOpts
+            });
+        }
+    }
+
     exports.AbstractMessageHandler = AbstractMessageHandler;
     exports.AbstractPrivateKeyStore = AbstractPrivateKeyStore;
     exports.AgentResolver = AgentResolver;
@@ -79124,6 +79351,7 @@ var PolygonIdSdk = (function (exports) {
     exports.PROTOCOL_CONSTANTS = constants;
     exports.PackageManager = PackageManager;
     exports.Parser = Parser;
+    exports.PaymentHandler = PaymentHandler;
     exports.PlainPacker = PlainPacker;
     exports.ProofNode = ProofNode;
     exports.ProofService = ProofService;
@@ -79175,6 +79403,8 @@ var PolygonIdSdk = (function (exports) {
     exports.core = index$1;
     exports.createAuthorizationRequest = createAuthorizationRequest;
     exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMessage;
+    exports.createPayment = createPayment;
+    exports.createPaymentRequest = createPaymentRequest;
     exports.createProposal = createProposal;
     exports.createProposalRequest = createProposalRequest;
     exports.createSchemaHash = createSchemaHash;