@0xpolygonid/js-sdk 1.12.0 → 1.14.0

package/dist/browser/umd/index.js

@@ -7496,6 +7496,42 @@ var PolygonIdSdk = (function (exports) {
     (function (RefreshServiceType) {
         RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
     })(exports.RefreshServiceType || (exports.RefreshServiceType = {}));
+    /**
+     * PaymentRequestType type for payment requests
+     * @beta
+     * @enum {string}
+     */
+    exports.PaymentRequestType = void 0;
+    (function (PaymentRequestType) {
+        PaymentRequestType["PaymentRequest"] = "PaymentRequest";
+    })(exports.PaymentRequestType || (exports.PaymentRequestType = {}));
+    /**
+     * PaymentRequestDataType type for payment requests
+     * @beta
+     * @enum {string}
+     */
+    exports.PaymentRequestDataType = void 0;
+    (function (PaymentRequestDataType) {
+        PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+    })(exports.PaymentRequestDataType || (exports.PaymentRequestDataType = {}));
+    /**
+     * PaymentType type for payment responses
+     * @beta
+     * @enum {string}
+     */
+    exports.PaymentType = void 0;
+    (function (PaymentType) {
+        PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+    })(exports.PaymentType || (exports.PaymentType = {}));
+    /**
+     * Media types for Payment supported currencies
+     * @beta
+     * @enum {number}
+     */
+    exports.SupportedCurrencies = void 0;
+    (function (SupportedCurrencies) {
+        SupportedCurrencies["ETH"] = "ETH";
+    })(exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
 
     /**
      * Iden3SparseMerkleProof is a iden3 protocol merkle tree proof
@@ -53622,7 +53658,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
@@ -54279,10 +54319,23 @@ var PolygonIdSdk = (function (exports) {
             if (!isValidOperation(query.datatype, propertyQuery.operator)) {
                 throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${query.datatype}`);
             }
-            query.values =
-                propertyQuery.operator === exports.Operators.EXISTS
-                    ? transformExistsValue(propertyQuery.operatorValue)
-                    : await transformQueryValueToBigInts(propertyQuery.operatorValue, query.datatype);
+            if ((propertyQuery.operator === exports.Operators.NOOP || propertyQuery.operator === exports.Operators.SD) &&
+                propertyQuery.operatorValue) {
+                throw new Error(`operator value should be undefined for ${propertyQuery.operator} operator`);
+            }
+            let values;
+            switch (propertyQuery.operator) {
+                case exports.Operators.NOOP:
+                case exports.Operators.SD:
+                    values = [];
+                    break;
+                case exports.Operators.EXISTS:
+                    values = transformExistsValue(propertyQuery.operatorValue);
+                    break;
+                default:
+                    values = await transformQueryValueToBigInts(propertyQuery.operatorValue, query.datatype);
+            }
+            query.values = values;
         }
         return query;
     };
@@ -78424,9 +78477,17 @@ var PolygonIdSdk = (function (exports) {
         }
         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:
@@ -78440,8 +78501,7 @@ var PolygonIdSdk = (function (exports) {
                 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 = v4();
                 const fetchRequest = {
                     id: guid,
@@ -78465,7 +78525,6 @@ var PolygonIdSdk = (function (exports) {
                     senderDID,
                     ...packerOpts
                 }));
-                let message;
                 try {
                     if (!offerMessage?.body?.url) {
                         throw new Error(`could not fetch W3C credential, body url is missing`);
@@ -78478,14 +78537,18 @@ var PolygonIdSdk = (function (exports) {
                         },
                         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;
@@ -78504,11 +78567,15 @@ var PolygonIdSdk = (function (exports) {
                 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) {
@@ -78521,7 +78588,7 @@ var PolygonIdSdk = (function (exports) {
             const userDID = Z$2.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');
@@ -79046,6 +79113,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 +79387,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 +79439,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;