@0xpolygonid/js-sdk 1.12.0 → 1.14.0

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

@@ -0,0 +1,203 @@
+import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { MediaType } from '../constants';
+import { DID } from '@iden3/js-iden3-core';
+import * as uuid from 'uuid';
+import { proving } from '@iden3/js-jwz';
+import { byteEncoder } from '../../utils';
+import { AbstractMessageHandler } from './message-handler';
+import { PaymentRequestDataType, PaymentRequestType, PaymentType } from '../../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`
+ */
+export function createPaymentRequest(sender, receiver, agent, payments) {
+    const uuidv4 = uuid.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`
+ */
+export function createPayment(sender, receiver, payments) {
+    const uuidv4 = uuid.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
+ */
+export 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 = DID.parse(paymentRequest.to);
+        const receiverDID = 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 !== PaymentRequestType.PaymentRequest) {
+                throw new Error(`failed request. not supported '${paymentReq.type}' payment type `);
+            }
+            if (paymentReq.data.type !== 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: 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 = 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 = byteEncoder.encode(JSON.stringify(message));
+        const packerOpts = this._params.packerParams.mediaType === MediaType.SignedMessage
+            ? this._params.packerParams.packerOptions
+            : {
+                provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        return await this._packerMgr.pack(this._params.packerParams.mediaType, responseEncoded, {
+            senderDID,
+            ...packerOpts
+        });
+    }
+}

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

@@ -5,5 +5,6 @@ export * from './protocol/proof';
 export * from './protocol/revocation';
 export * from './protocol/contract-request';
 export * from './protocol/proposal-request';
+export * from './protocol/payment';
 export * from './packer';
 export * from './packageManager';

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -110,3 +110,39 @@ export var RefreshServiceType;
 (function (RefreshServiceType) {
     RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
 })(RefreshServiceType || (RefreshServiceType = {}));
+/**
+ * PaymentRequestType type for payment requests
+ * @beta
+ * @enum {string}
+ */
+export var PaymentRequestType;
+(function (PaymentRequestType) {
+    PaymentRequestType["PaymentRequest"] = "PaymentRequest";
+})(PaymentRequestType || (PaymentRequestType = {}));
+/**
+ * PaymentRequestDataType type for payment requests
+ * @beta
+ * @enum {string}
+ */
+export var PaymentRequestDataType;
+(function (PaymentRequestDataType) {
+    PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+})(PaymentRequestDataType || (PaymentRequestDataType = {}));
+/**
+ * PaymentType type for payment responses
+ * @beta
+ * @enum {string}
+ */
+export var PaymentType;
+(function (PaymentType) {
+    PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+})(PaymentType || (PaymentType = {}));
+/**
+ * Media types for Payment supported currencies
+ * @beta
+ * @enum {number}
+ */
+export var SupportedCurrencies;
+(function (SupportedCurrencies) {
+    SupportedCurrencies["ETH"] = "ETH";
+})(SupportedCurrencies || (SupportedCurrencies = {}));

package/dist/types/iden3comm/constants.d.ts

@@ -19,6 +19,8 @@ export declare const PROTOCOL_MESSAGE_TYPE: Readonly<{
     CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: string;
     PROPOSAL_REQUEST_MESSAGE_TYPE: string;
     PROPOSAL_MESSAGE_TYPE: string;
+    PAYMENT_REQUEST_MESSAGE_TYPE: string;
+    PAYMENT_MESSAGE_TYPE: string;
 }>;
 /**
  * Media types for iden3 comm communication protocol

package/dist/types/iden3comm/handlers/index.d.ts

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

package/dist/types/iden3comm/handlers/message-handler.d.ts

@@ -2,6 +2,7 @@ import { BasicMessage, IPackageManager } from '../types';
 import { AuthMessageHandlerOptions } from './auth';
 import { RevocationStatusMessageHandlerOptions } from './revocation-status';
 import { ContractMessageHandlerOptions } from './contract-request';
+import { PaymentHandlerOptions, PaymentRequestMessageHandlerOptions } from './payment';
 /**
  * iden3  Protocol message handler interface
  */
@@ -77,7 +78,7 @@ export declare class MessageHandler {
      * @param context - An object containing information specific to the type of message being handled.
      * @returns A Promise that resolves to a Uint8Array of the packed response, or null if no response was generated.
      */
-    handleMessage(bytes: Uint8Array, context: AuthMessageHandlerOptions | ContractMessageHandlerOptions | RevocationStatusMessageHandlerOptions | ContractMessageHandlerOptions | {
+    handleMessage(bytes: Uint8Array, context: AuthMessageHandlerOptions | ContractMessageHandlerOptions | RevocationStatusMessageHandlerOptions | PaymentRequestMessageHandlerOptions | PaymentHandlerOptions | {
         [key: string]: unknown;
     }): Promise<Uint8Array | null>;
 }

package/dist/types/iden3comm/handlers/payment.d.ts

@@ -0,0 +1,100 @@
+import { BasicMessage, IPackageManager, PackerParams } from '../types';
+import { DID } from '@iden3/js-iden3-core';
+import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { PaymentInfo, PaymentMessage, PaymentRequestDataInfo, PaymentRequestInfo, PaymentRequestMessage } from '../types/protocol/payment';
+/**
+ * @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`
+ */
+export declare function createPaymentRequest(sender: DID, receiver: DID, agent: string, payments: PaymentRequestInfo[]): PaymentRequestMessage;
+/**
+ * @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`
+ */
+export declare function createPayment(sender: DID, receiver: DID, payments: PaymentInfo[]): PaymentMessage;
+/**
+ * @beta
+ * Interface that allows the processing of the payment-request and payment protocol messages
+ *
+ * @interface IPaymentHandler
+ */
+export interface IPaymentHandler {
+    /**
+     * @beta
+     * unpacks payment-request
+     * @param {Uint8Array} request - raw byte message
+     * @returns `Promise<PaymentRequestMessage>`
+     */
+    parsePaymentRequest(request: Uint8Array): Promise<PaymentRequestMessage>;
+    /**
+     *  @beta
+     * handle payment-request
+     * @param {Uint8Array} request - raw byte message
+     * @param {PaymentRequestMessageHandlerOptions} opts - handler options
+     * @returns {Promise<Uint8Array>} - agent message or null
+     */
+    handlePaymentRequest(request: Uint8Array, opts: PaymentRequestMessageHandlerOptions): Promise<Uint8Array | null>;
+    /**
+     * @beta
+     * handle payment protocol message
+     * @param {PaymentMessage} payment  - payment message
+     * @param {PaymentHandlerOptions} opts - options
+     * @returns `Promise<void>`
+     */
+    handlePayment(payment: PaymentMessage, opts: PaymentHandlerOptions): Promise<void>;
+}
+/** @beta PaymentRequestMessageHandlerOptions represents payment-request handler options */
+export type PaymentRequestMessageHandlerOptions = {
+    paymentHandler: (data: PaymentRequestDataInfo) => Promise<string>;
+};
+/** @beta PaymentHandlerOptions represents payment handler options */
+export type PaymentHandlerOptions = {
+    paymentRequest: PaymentRequestMessage;
+    paymentValidationHandler: (txId: string, data: PaymentRequestDataInfo) => Promise<void>;
+};
+/** @beta PaymentHandlerParams represents payment handler params */
+export type PaymentHandlerParams = {
+    packerParams: PackerParams;
+};
+/**
+ *
+ * Allows to process PaymentRequest protocol message
+ * @beta
+ * @class PaymentHandler
+ * @implements implements IPaymentHandler interface
+ */
+export declare class PaymentHandler extends AbstractMessageHandler implements IPaymentHandler, IProtocolMessageHandler {
+    private readonly _packerMgr;
+    private readonly _params;
+    /**
+     * @beta Creates an instance of PaymentHandler.
+     * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+     * @param {PaymentHandlerParams} _params - payment handler params
+     *
+     */
+    constructor(_packerMgr: IPackageManager, _params: PaymentHandlerParams);
+    handle(message: BasicMessage, context: PaymentRequestMessageHandlerOptions | PaymentHandlerOptions): Promise<BasicMessage | null>;
+    /**
+     * @inheritdoc IPaymentHandler#parsePaymentRequest
+     */
+    parsePaymentRequest(request: Uint8Array): Promise<PaymentRequestMessage>;
+    private handlePaymentRequestMessage;
+    /**
+     * @inheritdoc IPaymentHandler#handlePaymentRequest
+     */
+    handlePaymentRequest(request: Uint8Array, opts: PaymentRequestMessageHandlerOptions): Promise<Uint8Array | null>;
+    /**
+     * @inheritdoc IPaymentHandler#handlePayment
+     */
+    handlePayment(payment: PaymentMessage, opts: PaymentHandlerOptions): Promise<void>;
+    private packMessage;
+}

package/dist/types/iden3comm/types/index.d.ts

@@ -5,5 +5,6 @@ export * from './protocol/proof';
 export * from './protocol/revocation';
 export * from './protocol/contract-request';
 export * from './protocol/proposal-request';
+export * from './protocol/payment';
 export * from './packer';
 export * from './packageManager';

package/dist/types/iden3comm/types/protocol/credentials.d.ts

@@ -18,7 +18,7 @@ export type CredentialsOfferMessage = Required<BasicMessage> & {
 /** CredentialsOfferMessageBody is struct the represents offer message */
 export type CredentialsOfferMessageBody = {
     url: string;
-    credentials: Array<CredentialOffer>;
+    credentials: CredentialOffer[];
 };
 /** CredentialsOnchainOfferMessage represent Iden3message for credential onhcain offer message */
 export type CredentialsOnchainOfferMessage = Required<BasicMessage> & {
@@ -26,7 +26,7 @@ export type CredentialsOnchainOfferMessage = Required<BasicMessage> & {
 };
 /** CredentialsOnchainOfferMessageBody is struct the represents onchain offer message body */
 export type CredentialsOnchainOfferMessageBody = {
-    credentials: Array<CredentialOffer>;
+    credentials: CredentialOffer[];
     transaction_data: ContractInvokeTransactionData;
 };
 /** CredentialOffer is structure to fetch credential */
@@ -36,7 +36,7 @@ export type CredentialOffer = {
 };
 /** CredentialIssuanceMessage represent Iden3message for credential issuance */
 export type CredentialIssuanceMessage = Required<BasicMessage> & {
-    body?: IssuanceMessageBody;
+    body: IssuanceMessageBody;
 };
 /** IssuanceMessageBody is struct the represents message when credential is issued */
 export type IssuanceMessageBody = {

package/dist/types/iden3comm/types/protocol/payment.d.ts

@@ -0,0 +1,48 @@
+import { BasicMessage } from '../';
+import { PaymentRequestDataType, PaymentRequestType, PaymentType } from '../../../verifiable';
+/** @beta PaymentRequestMessage is struct the represents payment-request message */
+export type PaymentRequestMessage = BasicMessage & {
+    body?: PaymentRequestMessageBody;
+};
+/** @beta PaymentRequestMessageBody is struct the represents body for payment-request */
+export type PaymentRequestMessageBody = {
+    agent: string;
+    payments: PaymentRequestInfo[];
+};
+/** @beta PaymentRequestInfo is struct the represents payment info for payment-request */
+export type PaymentRequestInfo = {
+    credentials: {
+        type: string;
+        context: string;
+    }[];
+    type: PaymentRequestType;
+    data: PaymentRequestDataInfo;
+    expiration?: string;
+    description?: string;
+};
+/** @beta PaymentRequestDataInfo is struct the represents payment data info for payment-request */
+export type PaymentRequestDataInfo = {
+    type: PaymentRequestDataType;
+    amount: string;
+    id: number;
+    chainId: number;
+    address: string;
+    currency: string;
+    signature?: string;
+};
+/** @beta  PaymentMessage is struct the represents payment message */
+export type PaymentMessage = BasicMessage & {
+    body?: PaymentMessageBody;
+};
+/** @beta  PaymentMessageBody is struct the represents body for payment message */
+export type PaymentMessageBody = {
+    payments: PaymentInfo[];
+};
+/** @beta PaymentInfo is struct the represents payment info for payment */
+export type PaymentInfo = {
+    id: number;
+    type: PaymentType;
+    paymentData: {
+        txId: string;
+    };
+};

package/dist/types/verifiable/constants.d.ts

@@ -85,3 +85,35 @@ export declare enum SubjectPosition {
 export declare enum RefreshServiceType {
     Iden3RefreshService2023 = "Iden3RefreshService2023"
 }
+/**
+ * PaymentRequestType type for payment requests
+ * @beta
+ * @enum {string}
+ */
+export declare enum PaymentRequestType {
+    PaymentRequest = "PaymentRequest"
+}
+/**
+ * PaymentRequestDataType type for payment requests
+ * @beta
+ * @enum {string}
+ */
+export declare enum PaymentRequestDataType {
+    Iden3PaymentRequestCryptoV1 = "Iden3PaymentRequestCryptoV1"
+}
+/**
+ * PaymentType type for payment responses
+ * @beta
+ * @enum {string}
+ */
+export declare enum PaymentType {
+    Iden3PaymentCryptoV1 = "Iden3PaymentCryptoV1"
+}
+/**
+ * Media types for Payment supported currencies
+ * @beta
+ * @enum {number}
+ */
+export declare enum SupportedCurrencies {
+    ETH = "ETH"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xpolygonid/js-sdk",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "SDK to work with Polygon ID",
   "main": "dist/node/cjs/index.js",
   "module": "dist/node/esm/index.js",