@0xpolygonid/js-sdk 1.21.1 → 1.23.0

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

@@ -1,11 +1,13 @@
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { MediaType } from '../constants';
-import { DID } from '@iden3/js-iden3-core';
+import { DID, getUnixTimestamp } 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';
+import { PaymentFeatures, PaymentRequestDataType, PaymentType, SupportedPaymentProofType } from '../../verifiable';
+import { ethers } from 'ethers';
+import { verifyExpiresTime } from './common';
 /**
  * @beta
  * createPaymentRequest is a function to create protocol payment-request message
@@ -15,7 +17,7 @@ import { PaymentRequestDataType, PaymentRequestType, PaymentType } from '../../v
  * @param {PaymentRequestInfo[]} payments - payments
  * @returns `PaymentRequestMessage`
  */
-export function createPaymentRequest(sender, receiver, agent, payments) {
+export function createPaymentRequest(sender, receiver, agent, payments, opts) {
     const uuidv4 = uuid.v4();
     const request = {
         id: uuidv4,
@@ -27,19 +29,57 @@ export function createPaymentRequest(sender, receiver, agent, payments) {
         body: {
             agent,
             payments
-        }
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
+export async function verifyEIP712TypedData(data, resolver) {
+    const paymentData = data.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+        ? {
+            recipient: data.recipient,
+            amount: data.amount,
+            expirationDate: new Date(data.expirationDate).getTime(),
+            nonce: data.nonce,
+            metadata: '0x'
+        }
+        : {
+            tokenAddress: data.tokenAddress,
+            recipient: data.recipient,
+            amount: data.amount,
+            expirationDate: new Date(data.expirationDate).getTime(),
+            nonce: data.nonce,
+            metadata: '0x'
+        };
+    const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+    const typesFetchResult = await fetch(proof.eip712.types);
+    const types = await typesFetchResult.json();
+    delete types.EIP712Domain;
+    const recovered = ethers.verifyTypedData(proof.eip712.domain, types, paymentData, proof.proofValue);
+    const { didDocument } = await resolver.resolve(proof.verificationMethod);
+    if (didDocument?.verificationMethod) {
+        for (const verificationMethod of didDocument.verificationMethod) {
+            if (verificationMethod.blockchainAccountId?.split(':').slice(-1)[0].toLowerCase() ===
+                recovered.toLowerCase()) {
+                return recovered;
+            }
+        }
+    }
+    else {
+        throw new Error('failed request. issuer DIDDocument does not contain any verificationMethods');
+    }
+    throw new Error(`failed request. no matching verificationMethod`);
+}
 /**
  * @beta
  * createPayment is a function to create protocol payment message
  * @param {DID} sender - sender did
  * @param {DID} receiver - receiver did
- * @param {PaymentInfo[]} payments - payments
+ * @param {PaymentMessageBody} body - payments
  * @returns `PaymentMessage`
  */
-export function createPayment(sender, receiver, payments) {
+export function createPayment(sender, receiver, payments, opts) {
     const uuidv4 = uuid.v4();
     const request = {
         id: uuidv4,
@@ -50,7 +90,9 @@ export function createPayment(sender, receiver, payments) {
         type: PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE,
         body: {
             payments
-        }
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -112,21 +154,28 @@ export class PaymentHandler extends AbstractMessageHandler {
         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 `);
+            const { data } = paymentRequest.body.payments[i];
+            const selectedPayment = Array.isArray(data)
+                ? data.find((p) => {
+                    return p.type === PaymentRequestDataType.Iden3PaymentRequestCryptoV1
+                        ? p.id === ctx.nonce
+                        : p.nonce === ctx.nonce;
+                })
+                : data;
+            if (!selectedPayment) {
+                throw new Error(`failed request. no payment in request for nonce ${ctx.nonce}`);
             }
-            if (paymentReq.data.type !== PaymentRequestDataType.Iden3PaymentRequestCryptoV1) {
-                throw new Error(`failed request. not supported '${paymentReq.data.type}' payment type `);
+            switch (selectedPayment.type) {
+                case PaymentRequestDataType.Iden3PaymentRequestCryptoV1:
+                    payments.push(await this.handleIden3PaymentRequestCryptoV1(selectedPayment, ctx.paymentHandler));
+                    break;
+                case PaymentRequestDataType.Iden3PaymentRailsRequestV1:
+                    payments.push(await this.handleIden3PaymentRailsRequestV1(selectedPayment, ctx.paymentHandler));
+                    break;
+                case PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1:
+                    payments.push(await this.handleIden3PaymentRailsERC20RequestV1(selectedPayment, ctx.paymentHandler, ctx.erc20TokenApproveHandler));
+                    break;
             }
-            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);
@@ -159,6 +208,9 @@ export class PaymentHandler extends AbstractMessageHandler {
         if (!paymentRequest.to) {
             throw new Error(`failed request. empty 'to' field`);
         }
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(paymentRequest);
+        }
         const agentMessage = await this.handlePaymentRequestMessage(paymentRequest, opts);
         if (!agentMessage) {
             return null;
@@ -169,24 +221,122 @@ export class PaymentHandler extends AbstractMessageHandler {
     /**
      * @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}`);
+    async handlePayment(payment, params) {
+        if (!params?.allowExpiredMessages) {
+            verifyExpiresTime(payment);
+        }
+        if (params.paymentRequest.from !== payment.to) {
+            throw new Error(`sender of the request is not a target of response - expected ${params.paymentRequest.from}, given ${payment.to}`);
         }
         if (!payment.body.payments.length) {
             throw new Error(`failed request. empty 'payments' field in body`);
         }
+        if (!params.paymentValidationHandler) {
+            throw new Error(`please provide payment validation handler in options`);
+        }
         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}`);
+            const nonce = p.type === PaymentType.Iden3PaymentCryptoV1 ? p.id : p.nonce;
+            const requestDataArr = params.paymentRequest.body.payments
+                .map((r) => (Array.isArray(r.data) ? r.data : [r.data]))
+                .flat();
+            const requestData = requestDataArr.find((r) => r.type === PaymentRequestDataType.Iden3PaymentRequestCryptoV1
+                ? r.id === nonce
+                : r.nonce === nonce);
+            if (!requestData) {
+                throw new Error(`can't find payment request for payment ${p.type === PaymentType.Iden3PaymentCryptoV1 ? 'id' : 'nonce'} ${nonce}`);
             }
-            if (!opts.paymentValidationHandler) {
-                throw new Error(`please provide payment validation handler in options`);
+            await params.paymentValidationHandler(p.paymentData.txId, requestData);
+        }
+    }
+    /**
+     * @inheritdoc IPaymentHandler#createPaymentRailsV1
+     */
+    async createPaymentRailsV1(sender, receiver, agent, signer, payments) {
+        const paymentRequestInfo = [];
+        for (let i = 0; i < payments.length; i++) {
+            const { credentials, description } = payments[i];
+            const dataArr = [];
+            for (let j = 0; j < payments[i].chains.length; j++) {
+                const { features, nonce, amount, currency, chainId, expirationDate, type } = payments[i].chains[j];
+                const multiChainConfig = this._params.multiChainPaymentConfig?.find((c) => c.chainId === chainId);
+                if (!multiChainConfig) {
+                    throw new Error(`failed request. no config for chain ${chainId}`);
+                }
+                const { recipient, paymentContract, erc20TokenAddressArr } = multiChainConfig;
+                const tokenAddress = erc20TokenAddressArr.find((t) => t.symbol === currency)?.address;
+                if (type === PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
+                    throw new Error(`failed request. no token address for currency ${currency}`);
+                }
+                const expirationTime = expirationDate
+                    ? new Date(expirationDate).getTime()
+                    : new Date(new Date().setHours(new Date().getHours() + 1)).getTime();
+                const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
+                const typesFetchResult = await fetch(typeUrl);
+                const types = await typesFetchResult.json();
+                delete types.EIP712Domain;
+                const paymentData = type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    ? {
+                        recipient,
+                        amount,
+                        expirationDate: expirationTime,
+                        nonce,
+                        metadata: '0x'
+                    }
+                    : {
+                        tokenAddress,
+                        recipient,
+                        amount,
+                        expirationDate: expirationTime,
+                        nonce,
+                        metadata: '0x'
+                    };
+                const domain = {
+                    name: 'MCPayment',
+                    version: '1.0.0',
+                    chainId,
+                    verifyingContract: paymentContract
+                };
+                const signature = await signer.signTypedData(domain, types, paymentData);
+                const proof = [
+                    {
+                        type: SupportedPaymentProofType.EthereumEip712Signature2021,
+                        proofPurpose: 'assertionMethod',
+                        proofValue: signature,
+                        verificationMethod: `did:pkh:eip155:${chainId}:${await signer.getAddress()}`,
+                        created: new Date().toISOString(),
+                        eip712: {
+                            types: typeUrl,
+                            primaryType: 'Iden3PaymentRailsRequestV1',
+                            domain
+                        }
+                    }
+                ];
+                const d = {
+                    type: PaymentRequestDataType.Iden3PaymentRailsRequestV1,
+                    '@context': [
+                        `https://schema.iden3.io/core/jsonld/payment.jsonld#${type}`,
+                        'https://w3id.org/security/suites/eip712sig-2021/v1'
+                    ],
+                    recipient,
+                    amount: amount.toString(),
+                    currency,
+                    expirationDate: new Date(expirationTime).toISOString(),
+                    nonce: nonce.toString(),
+                    metadata: '0x',
+                    proof
+                };
+                dataArr.push(type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    ? d
+                    : { ...d, type, tokenAddress: tokenAddress || '', features: features || [] });
             }
-            await opts.paymentValidationHandler(p.paymentData.txId, paymentRequestData.data);
+            paymentRequestInfo.push({
+                data: dataArr,
+                credentials,
+                description
+            });
         }
+        return createPaymentRequest(sender, receiver, agent, paymentRequestInfo);
     }
     async packMessage(message, senderDID) {
         const responseEncoded = byteEncoder.encode(JSON.stringify(message));
@@ -200,4 +350,65 @@ export class PaymentHandler extends AbstractMessageHandler {
             ...packerOpts
         });
     }
+    async handleIden3PaymentRequestCryptoV1(data, paymentHandler) {
+        if (data.expiration && new Date(data.expiration) < new Date()) {
+            throw new Error(`failed request. expired request`);
+        }
+        const txId = await paymentHandler(data);
+        return {
+            id: data.id,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentCryptoV1',
+            type: PaymentType.Iden3PaymentCryptoV1,
+            paymentData: {
+                txId
+            }
+        };
+    }
+    async handleIden3PaymentRailsRequestV1(data, paymentHandler) {
+        if (data.expirationDate && new Date(data.expirationDate) < new Date()) {
+            throw new Error(`failed request. expired request`);
+        }
+        const signer = await verifyEIP712TypedData(data, this._params.documentResolver);
+        if (this._params.allowedSigners && !this._params.allowedSigners.includes(signer)) {
+            throw new Error(`failed request. signer is not in the allowed signers list`);
+        }
+        const txId = await paymentHandler(data);
+        const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+        return {
+            nonce: data.nonce,
+            type: PaymentType.Iden3PaymentRailsV1,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsV1',
+            paymentData: {
+                txId,
+                chainId: proof.eip712.domain.chainId
+            }
+        };
+    }
+    async handleIden3PaymentRailsERC20RequestV1(data, paymentHandler, approveHandler) {
+        if (data.expirationDate && new Date(data.expirationDate) < new Date()) {
+            throw new Error(`failed request. expired request`);
+        }
+        const signer = await verifyEIP712TypedData(data, this._params.documentResolver);
+        if (this._params.allowedSigners && !this._params.allowedSigners.includes(signer)) {
+            throw new Error(`failed request. signer is not in the allowed signers list`);
+        }
+        if (!data.features?.includes(PaymentFeatures.EIP_2612) && !approveHandler) {
+            throw new Error(`please provide erc20TokenApproveHandler in context for ERC-20 payment type`);
+        }
+        if (approveHandler) {
+            await approveHandler(data);
+        }
+        const txId = await paymentHandler(data);
+        const proof = Array.isArray(data.proof) ? data.proof[0] : data.proof;
+        return {
+            nonce: data.nonce,
+            type: PaymentType.Iden3PaymentRailsERC20V1,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsERC20V1',
+            paymentData: {
+                txId,
+                chainId: proof.eip712.domain.chainId,
+                tokenAddress: data.tokenAddress
+            }
+        };
+    }
 }

package/dist/node/esm/iden3comm/handlers/revocation-status.js

@@ -5,6 +5,7 @@ import * as uuid from 'uuid';
 import { byteEncoder } from '../../utils';
 import { proving } from '@iden3/js-jwz';
 import { AbstractMessageHandler } from './message-handler';
+import { verifyExpiresTime } from './common';
 /**
  *
  * Allows to process RevocationStatusRequest protocol message
@@ -97,6 +98,9 @@ export class RevocationStatusHandler extends AbstractMessageHandler {
             throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
         }
         const rsRequest = await this.parseRevocationStatusRequest(request);
+        if (!opts.allowExpiredMessages) {
+            verifyExpiresTime(rsRequest);
+        }
         const response = await this.handleRevocationStatusRequestMessage(rsRequest, {
             senderDid: did,
             mediaType: opts.mediaType,

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

@@ -3,5 +3,6 @@ export * from './packers';
 export * from './types';
 export * from './handlers';
 export * from './utils/did';
+export * from './utils/accept-profile';
 import * as PROTOCOL_CONSTANTS from './constants';
 export { PROTOCOL_CONSTANTS };

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

@@ -15,6 +15,18 @@ export class PackageManager {
     constructor() {
         this.packers = new Map();
     }
+    /** {@inheritDoc IPackageManager.isProfileSupported} */
+    isProfileSupported(mediaType, profile) {
+        const p = this.packers.get(mediaType);
+        if (!p) {
+            return false;
+        }
+        return p.isProfileSupported(profile);
+    }
+    /** {@inheritDoc IPackageManager.getSupportedMediaTypes} */
+    getSupportedMediaTypes() {
+        return [...this.packers.keys()];
+    }
     /** {@inheritDoc IPackageManager.registerPackers} */
     registerPackers(packers) {
         packers.forEach((p) => {

package/dist/node/esm/iden3comm/packers/jws.js

@@ -1,10 +1,11 @@
-import { MediaType, SUPPORTED_PUBLIC_KEY_TYPES } from '../constants';
+import { AcceptJwsAlgorithms, MediaType, SUPPORTED_PUBLIC_KEY_TYPES } from '../constants';
 import { extractPublicKeyBytes, resolveVerificationMethods } from '../utils/did';
 import { keyPath } from '../../kms/';
 import { verifyJWS } from 'did-jwt';
 import { parse } from 'did-resolver';
 import { bytesToBase64url } from '../../utils/encoding';
 import { byteDecoder, byteEncoder, bytesToHex, decodeBase64url, encodeBase64url } from '../../utils';
+import { parseAcceptProfile } from '../utils';
 /**
  * Packer that can pack message to JWZ token,
  * and unpack and validate JWZ envelope
@@ -83,6 +84,26 @@ export class JWSPacker {
     mediaType() {
         return MediaType.SignedMessage;
     }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [`env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}`];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = parseAcceptProfile(profile);
+        if (env !== this.mediaType()) {
+            return false;
+        }
+        if (circuits) {
+            throw new Error(`Circuits are not supported for ${env} media type`);
+        }
+        const supportedAlgArr = this.getSupportedAlgorithms();
+        const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
+        return algSupported;
+    }
+    getSupportedAlgorithms() {
+        return [AcceptJwsAlgorithms.ES256K, AcceptJwsAlgorithms.ES256KR];
+    }
     async resolveDidDoc(from) {
         let didDocument;
         try {

package/dist/node/esm/iden3comm/packers/plain.js

@@ -1,5 +1,6 @@
 import { MediaType } from '../constants';
 import { byteDecoder, byteEncoder } from '../../utils';
+import { parseAcceptProfile } from '../utils';
 /**
  * Plain packer just serializes bytes to JSON and adds media type
  *
@@ -49,4 +50,22 @@ export class PlainPacker {
     mediaType() {
         return MediaType.PlainMessage;
     }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [`env=${this.mediaType()}`];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = parseAcceptProfile(profile);
+        if (env !== this.mediaType()) {
+            return false;
+        }
+        if (circuits) {
+            throw new Error(`Circuits are not supported for ${env} media type`);
+        }
+        if (alg) {
+            throw new Error(`Algorithms are not supported for ${env} media type`);
+        }
+        return true;
+    }
 }

package/dist/node/esm/iden3comm/packers/zkp.js

@@ -3,9 +3,10 @@ import { AuthV2PubSignals, CircuitId } from '../../circuits/index';
 import { BytesHelper, DID } from '@iden3/js-iden3-core';
 import { bytesToProtocolMessage } from '../utils/envelope';
 import { ErrNoProvingMethodAlg, ErrPackedWithUnsupportedCircuit, ErrProofIsInvalid, ErrSenderNotUsedTokenCreation, ErrStateVerificationFailed, ErrUnknownCircuitID } from '../errors';
-import { MediaType } from '../constants';
+import { AcceptAuthCircuits, AcceptJwzAlgorithms, MediaType } from '../constants';
 import { byteDecoder, byteEncoder } from '../../utils';
 import { DEFAULT_AUTH_VERIFY_DELAY } from '../constants';
+import { parseAcceptProfile } from '../utils';
 const { getProvingMethod } = proving;
 /**
  * Handler to
@@ -136,6 +137,30 @@ export class ZKPPacker {
     mediaType() {
         return MediaType.ZKPMessage;
     }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [
+            `env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}&circuitIds=${this.getSupportedCircuitIds().join(',')}`
+        ];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = parseAcceptProfile(profile);
+        if (env !== this.mediaType()) {
+            return false;
+        }
+        const supportedCircuitIds = this.getSupportedCircuitIds();
+        const circuitIdSupported = !circuits?.length || circuits.some((c) => supportedCircuitIds.includes(c));
+        const supportedAlgArr = this.getSupportedAlgorithms();
+        const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
+        return algSupported && circuitIdSupported;
+    }
+    getSupportedAlgorithms() {
+        return [AcceptJwzAlgorithms.Groth16];
+    }
+    getSupportedCircuitIds() {
+        return [AcceptAuthCircuits.AuthV2];
+    }
 }
 const verifySender = async (token, msg) => {
     switch (token.circuitId) {

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

@@ -6,6 +6,7 @@ export * from './protocol/revocation';
 export * from './protocol/contract-request';
 export * from './protocol/proposal-request';
 export * from './protocol/payment';
+export * from './protocol/accept-profile';
 export * from './packer';
 export * from './models';
 export * from './packageManager';

package/dist/node/esm/iden3comm/types/protocol/accept-profile.js

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

package/dist/node/esm/iden3comm/utils/accept-profile.js

@@ -0,0 +1,102 @@
+import { MediaType, ProtocolVersion, AcceptAuthCircuits, AcceptJwzAlgorithms, AcceptJwsAlgorithms } from '../constants';
+function isProtocolVersion(value) {
+    return Object.values(ProtocolVersion).includes(value);
+}
+function isMediaType(value) {
+    return Object.values(MediaType).includes(value);
+}
+function isAcceptAuthCircuits(value) {
+    return Object.values(AcceptAuthCircuits).includes(value);
+}
+function isAcceptJwsAlgorithms(value) {
+    return Object.values(AcceptJwsAlgorithms).includes(value);
+}
+function isAcceptJwzAlgorithms(value) {
+    return Object.values(AcceptJwzAlgorithms).includes(value);
+}
+export const buildAccept = (profiles) => {
+    const result = [];
+    for (const profile of profiles) {
+        let accept = `${profile.protocolVersion};env=${profile.env}`;
+        if (profile.circuits?.length) {
+            accept += `;circuitId=${profile.circuits.join(',')}`;
+        }
+        if (profile.alg?.length) {
+            accept += `;alg=${profile.alg.join(',')}`;
+        }
+        result.push(accept);
+    }
+    return result;
+};
+export const parseAcceptProfile = (profile) => {
+    const params = profile.split(';');
+    if (params.length < 2) {
+        throw new Error('Invalid accept profile');
+    }
+    const protocolVersion = params[0].trim();
+    if (!isProtocolVersion(protocolVersion)) {
+        throw new Error(`Protocol version '${protocolVersion}' not supported`);
+    }
+    const envParam = params[1].split('=');
+    if (envParam.length !== 2) {
+        throw new Error(`Invalid accept profile 'env' parameter`);
+    }
+    const env = params[1].split('=')[1].trim();
+    if (!isMediaType(env)) {
+        throw new Error(`Envelop '${env}' not supported`);
+    }
+    const circuitsIndex = params.findIndex((i) => i.includes('circuitId='));
+    if (env !== MediaType.ZKPMessage && circuitsIndex > 0) {
+        throw new Error(`Circuits not supported for env '${env}'`);
+    }
+    let circuits = undefined;
+    if (circuitsIndex > 0) {
+        circuits = params[circuitsIndex]
+            .split('=')[1]
+            .split(',')
+            .map((i) => i.trim())
+            .map((i) => {
+            if (!isAcceptAuthCircuits(i)) {
+                throw new Error(`Circuit '${i}' not supported`);
+            }
+            return i;
+        });
+    }
+    const algIndex = params.findIndex((i) => i.includes('alg='));
+    let alg = undefined;
+    if (algIndex > 0) {
+        if (env === MediaType.ZKPMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwzAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else if (env === MediaType.SignedMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwsAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else {
+            throw new Error(`Algorithm not supported for '${env}'`);
+        }
+    }
+    return {
+        protocolVersion,
+        env,
+        circuits,
+        alg
+    };
+};

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

@@ -1,3 +1,4 @@
 export * from './envelope';
 export * from './message';
 export * from './did';
+export * from './accept-profile';

package/dist/node/esm/proof/provers/inputs-generator.js

@@ -12,7 +12,8 @@ const v2Operations = [
     Operators.GT,
     Operators.IN,
     Operators.NIN,
-    Operators.NE
+    Operators.NE,
+    Operators.SD
 ];
 const v2OnChainOperations = [
     Operators.EQ,

package/dist/node/esm/storage/blockchain/abi/ERC20Permit.json

@@ -0,0 +1 @@
+[{ "inputs": [], "name": "ECDSAInvalidSignature", "type": "error" }, { "inputs": [{ "internalType": "uint256", "name": "length", "type": "uint256" }], "name": "ECDSAInvalidSignatureLength", "type": "error" }, { "inputs": [{ "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "ECDSAInvalidSignatureS", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "allowance", "type": "uint256" }, { "internalType": "uint256", "name": "needed", "type": "uint256" }], "name": "ERC20InsufficientAllowance", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "sender", "type": "address" }, { "internalType": "uint256", "name": "balance", "type": "uint256" }, { "internalType": "uint256", "name": "needed", "type": "uint256" }], "name": "ERC20InsufficientBalance", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "approver", "type": "address" }], "name": "ERC20InvalidApprover", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "receiver", "type": "address" }], "name": "ERC20InvalidReceiver", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "sender", "type": "address" }], "name": "ERC20InvalidSender", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }], "name": "ERC20InvalidSpender", "type": "error" }, { "inputs": [{ "internalType": "uint256", "name": "deadline", "type": "uint256" }], "name": "ERC2612ExpiredSignature", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "signer", "type": "address" }, { "internalType": "address", "name": "owner", "type": "address" }], "name": "ERC2612InvalidSigner", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }, { "internalType": "uint256", "name": "currentNonce", "type": "uint256" }], "name": "InvalidAccountNonce", "type": "error" }, { "inputs": [], "name": "InvalidShortString", "type": "error" }, { "inputs": [{ "internalType": "string", "name": "str", "type": "string" }], "name": "StringTooLong", "type": "error" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "owner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "spender", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Approval", "type": "event" }, { "anonymous": false, "inputs": [], "name": "EIP712DomainChanged", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "from", "type": "address" }, { "indexed": true, "internalType": "address", "name": "to", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "Transfer", "type": "event" }, { "inputs": [], "name": "DOMAIN_SEPARATOR", "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "address", "name": "spender", "type": "address" }], "name": "allowance", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "approve", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }], "name": "balanceOf", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "decimals", "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "eip712Domain", "outputs": [{ "internalType": "bytes1", "name": "fields", "type": "bytes1" }, { "internalType": "string", "name": "name", "type": "string" }, { "internalType": "string", "name": "version", "type": "string" }, { "internalType": "uint256", "name": "chainId", "type": "uint256" }, { "internalType": "address", "name": "verifyingContract", "type": "address" }, { "internalType": "bytes32", "name": "salt", "type": "bytes32" }, { "internalType": "uint256[]", "name": "extensions", "type": "uint256[]" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "name", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }], "name": "nonces", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "address", "name": "spender", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "uint256", "name": "deadline", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "permit", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "symbol", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalSupply", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transfer", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "from", "type": "address" }, { "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "transferFrom", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" }]