@0xpolygonid/js-sdk 1.21.3 → 1.24.1

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

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentHandler = exports.createPayment = exports.createPaymentRequest = void 0;
+exports.PaymentHandler = exports.createPayment = exports.convertPaymentAmount = exports.verifyEIP712TypedData = exports.createPaymentRequest = void 0;
 const constants_1 = require("../constants");
 const constants_2 = require("../constants");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
@@ -32,6 +32,8 @@ 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");
+const ethers_1 = require("ethers");
+const common_1 = require("./common");
 /**
  * @beta
  * createPaymentRequest is a function to create protocol payment-request message
@@ -41,7 +43,7 @@ const verifiable_1 = require("../../verifiable");
  * @param {PaymentRequestInfo[]} payments - payments
  * @returns `PaymentRequestMessage`
  */
-function createPaymentRequest(sender, receiver, agent, payments) {
+function createPaymentRequest(sender, receiver, agent, payments, opts) {
     const uuidv4 = uuid.v4();
     const request = {
         id: uuidv4,
@@ -53,20 +55,85 @@ function createPaymentRequest(sender, receiver, agent, payments) {
         body: {
             agent,
             payments
-        }
+        },
+        created_time: (0, js_iden3_core_1.getUnixTimestamp)(new Date()),
+        expires_time: opts?.expires_time ? (0, js_iden3_core_1.getUnixTimestamp)(opts.expires_time) : undefined
     };
     return request;
 }
 exports.createPaymentRequest = createPaymentRequest;
+async function verifyEIP712TypedData(data, resolver) {
+    const convertedAmount = await convertPaymentAmount(data.amount, data.currency);
+    const paymentData = data.type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+        ? {
+            recipient: data.recipient,
+            amount: convertedAmount,
+            expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(new Date(data.expirationDate)),
+            nonce: data.nonce,
+            metadata: '0x'
+        }
+        : {
+            tokenAddress: data.tokenAddress,
+            recipient: data.recipient,
+            amount: convertedAmount,
+            expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(new Date(data.expirationDate)),
+            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_1.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`);
+}
+exports.verifyEIP712TypedData = verifyEIP712TypedData;
+async function convertPaymentAmount(amount, currency) {
+    let convertedAmount = 0n;
+    switch (currency) {
+        case verifiable_1.SupportedCurrencies.ETH:
+        case verifiable_1.SupportedCurrencies.POL:
+        case verifiable_1.SupportedCurrencies.MATIC:
+            convertedAmount = (0, ethers_1.parseEther)(amount.toString());
+            break;
+        case verifiable_1.SupportedCurrencies.ETH_WEI:
+            convertedAmount = (0, ethers_1.parseUnits)(amount.toString(), 'wei');
+            break;
+        case verifiable_1.SupportedCurrencies.ETH_GWEI:
+            convertedAmount = (0, ethers_1.parseUnits)(amount.toString(), 'gwei');
+            break;
+        case verifiable_1.SupportedCurrencies.USDC:
+        case verifiable_1.SupportedCurrencies.USDT: {
+            convertedAmount = (0, ethers_1.parseUnits)(amount.toString(), 6);
+            break;
+        }
+        default:
+            throw new Error(`failed request. unsupported currency ${currency}`);
+    }
+    return convertedAmount;
+}
+exports.convertPaymentAmount = convertPaymentAmount;
 /**
  * @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`
  */
-function createPayment(sender, receiver, payments) {
+function createPayment(sender, receiver, payments, opts) {
     const uuidv4 = uuid.v4();
     const request = {
         id: uuidv4,
@@ -77,7 +144,9 @@ function createPayment(sender, receiver, payments) {
         type: constants_1.PROTOCOL_MESSAGE_TYPE.PAYMENT_MESSAGE_TYPE,
         body: {
             payments
-        }
+        },
+        created_time: (0, js_iden3_core_1.getUnixTimestamp)(new Date()),
+        expires_time: opts?.expires_time ? (0, js_iden3_core_1.getUnixTimestamp)(opts.expires_time) : undefined
     };
     return request;
 }
@@ -140,21 +209,28 @@ class PaymentHandler extends message_handler_1.AbstractMessageHandler {
         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 `);
+            const { data } = paymentRequest.body.payments[i];
+            const selectedPayment = Array.isArray(data)
+                ? data.find((p) => {
+                    return p.type === verifiable_1.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 !== verifiable_1.PaymentRequestDataType.Iden3PaymentRequestCryptoV1) {
-                throw new Error(`failed request. not supported '${paymentReq.data.type}' payment type `);
+            switch (selectedPayment.type) {
+                case verifiable_1.PaymentRequestDataType.Iden3PaymentRequestCryptoV1:
+                    payments.push(await this.handleIden3PaymentRequestCryptoV1(selectedPayment, ctx.paymentHandler));
+                    break;
+                case verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1:
+                    payments.push(await this.handleIden3PaymentRailsRequestV1(selectedPayment, ctx.paymentHandler));
+                    break;
+                case verifiable_1.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: verifiable_1.PaymentType.Iden3PaymentCryptoV1,
-                paymentData: {
-                    txId
-                }
-            });
         }
         const paymentMessage = createPayment(senderDID, receiverDID, payments);
         const response = await this.packMessage(paymentMessage, senderDID);
@@ -187,6 +263,9 @@ class PaymentHandler extends message_handler_1.AbstractMessageHandler {
         if (!paymentRequest.to) {
             throw new Error(`failed request. empty 'to' field`);
         }
+        if (!opts?.allowExpiredMessages) {
+            (0, common_1.verifyExpiresTime)(paymentRequest);
+        }
         const agentMessage = await this.handlePaymentRequestMessage(paymentRequest, opts);
         if (!agentMessage) {
             return null;
@@ -197,24 +276,121 @@ class PaymentHandler extends message_handler_1.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) {
+            (0, common_1.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 === verifiable_1.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 === verifiable_1.PaymentRequestDataType.Iden3PaymentRequestCryptoV1
+                ? r.id === nonce
+                : r.nonce === nonce);
+            if (!requestData) {
+                throw new Error(`can't find payment request for payment ${p.type === verifiable_1.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 === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
+                    throw new Error(`failed request. no token address for currency ${currency}`);
+                }
+                const expirationDateRequired = expirationDate ?? new Date(new Date().setHours(new Date().getHours() + 1));
+                const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
+                const typesFetchResult = await fetch(typeUrl);
+                const types = await typesFetchResult.json();
+                delete types.EIP712Domain;
+                const convertedAmount = await convertPaymentAmount(amount, currency);
+                const paymentData = type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    ? {
+                        recipient,
+                        amount: convertedAmount,
+                        expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(expirationDateRequired),
+                        nonce,
+                        metadata: '0x'
+                    }
+                    : {
+                        tokenAddress,
+                        recipient,
+                        amount: convertedAmount,
+                        expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(expirationDateRequired),
+                        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: verifiable_1.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: verifiable_1.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: expirationDateRequired.toISOString(),
+                    nonce: nonce.toString(),
+                    metadata: '0x',
+                    proof
+                };
+                dataArr.push(type === verifiable_1.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 = utils_1.byteEncoder.encode(JSON.stringify(message));
@@ -228,5 +404,66 @@ class PaymentHandler extends message_handler_1.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: verifiable_1.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: verifiable_1.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(verifiable_1.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: verifiable_1.PaymentType.Iden3PaymentRailsERC20V1,
+            '@context': 'https://schema.iden3.io/core/jsonld/payment.jsonld#Iden3PaymentRailsERC20V1',
+            paymentData: {
+                txId,
+                chainId: proof.eip712.domain.chainId,
+                tokenAddress: data.tokenAddress
+            }
+        };
+    }
 }
 exports.PaymentHandler = PaymentHandler;

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

@@ -31,6 +31,7 @@ const uuid = __importStar(require("uuid"));
 const utils_1 = require("../../utils");
 const js_jwz_1 = require("@iden3/js-jwz");
 const message_handler_1 = require("./message-handler");
+const common_1 = require("./common");
 /**
  *
  * Allows to process RevocationStatusRequest protocol message
@@ -123,6 +124,9 @@ class RevocationStatusHandler extends message_handler_1.AbstractMessageHandler {
             throw new Error(`jws packer options are required for ${constants_2.MediaType.SignedMessage}`);
         }
         const rsRequest = await this.parseRevocationStatusRequest(request);
+        if (!opts.allowExpiredMessages) {
+            (0, common_1.verifyExpiresTime)(rsRequest);
+        }
         const response = await this.handleRevocationStatusRequestMessage(rsRequest, {
             senderDid: did,
             mediaType: opts.mediaType,

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

@@ -32,5 +32,6 @@ __exportStar(require("./packers"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./handlers"), exports);
 __exportStar(require("./utils/did"), exports);
+__exportStar(require("./utils/accept-profile"), exports);
 const PROTOCOL_CONSTANTS = __importStar(require("./constants"));
 exports.PROTOCOL_CONSTANTS = PROTOCOL_CONSTANTS;

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

@@ -18,6 +18,18 @@ 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/cjs/iden3comm/packers/jws.js

@@ -8,6 +8,7 @@ const did_jwt_1 = require("did-jwt");
 const did_resolver_1 = require("did-resolver");
 const encoding_1 = require("../../utils/encoding");
 const utils_1 = require("../../utils");
+const utils_2 = require("../utils");
 /**
  * Packer that can pack message to JWZ token,
  * and unpack and validate JWZ envelope
@@ -86,6 +87,26 @@ class JWSPacker {
     mediaType() {
         return constants_1.MediaType.SignedMessage;
     }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [`env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}`];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = (0, utils_2.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 [constants_1.AcceptJwsAlgorithms.ES256K, constants_1.AcceptJwsAlgorithms.ES256KR];
+    }
     async resolveDidDoc(from) {
         let didDocument;
         try {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlainPacker = void 0;
 const constants_1 = require("../constants");
 const utils_1 = require("../../utils");
+const utils_2 = require("../utils");
 /**
  * Plain packer just serializes bytes to JSON and adds media type
  *
@@ -52,5 +53,23 @@ class PlainPacker {
     mediaType() {
         return constants_1.MediaType.PlainMessage;
     }
+    /** {@inheritDoc IPacker.getSupportedProfiles} */
+    getSupportedProfiles() {
+        return [`env=${this.mediaType()}`];
+    }
+    /** {@inheritDoc IPacker.isProfileSupported} */
+    isProfileSupported(profile) {
+        const { env, circuits, alg } = (0, utils_2.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;
+    }
 }
 exports.PlainPacker = PlainPacker;

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

@@ -9,6 +9,7 @@ const errors_1 = require("../errors");
 const constants_1 = require("../constants");
 const utils_1 = require("../../utils");
 const constants_2 = require("../constants");
+const utils_2 = require("../utils");
 const { getProvingMethod } = js_jwz_1.proving;
 /**
  * Handler to
@@ -141,6 +142,30 @@ class ZKPPacker {
     mediaType() {
         return constants_1.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 } = (0, utils_2.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 [constants_1.AcceptJwzAlgorithms.Groth16];
+    }
+    getSupportedCircuitIds() {
+        return [constants_1.AcceptAuthCircuits.AuthV2];
+    }
 }
 exports.ZKPPacker = ZKPPacker;
 const verifySender = async (token, msg) => {

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

@@ -22,6 +22,7 @@ __exportStar(require("./protocol/revocation"), exports);
 __exportStar(require("./protocol/contract-request"), exports);
 __exportStar(require("./protocol/proposal-request"), exports);
 __exportStar(require("./protocol/payment"), exports);
+__exportStar(require("./protocol/accept-profile"), exports);
 __exportStar(require("./packer"), exports);
 __exportStar(require("./models"), exports);
 __exportStar(require("./packageManager"), exports);

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

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

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAcceptProfile = exports.buildAccept = void 0;
+const constants_1 = require("../constants");
+function isProtocolVersion(value) {
+    return Object.values(constants_1.ProtocolVersion).includes(value);
+}
+function isMediaType(value) {
+    return Object.values(constants_1.MediaType).includes(value);
+}
+function isAcceptAuthCircuits(value) {
+    return Object.values(constants_1.AcceptAuthCircuits).includes(value);
+}
+function isAcceptJwsAlgorithms(value) {
+    return Object.values(constants_1.AcceptJwsAlgorithms).includes(value);
+}
+function isAcceptJwzAlgorithms(value) {
+    return Object.values(constants_1.AcceptJwzAlgorithms).includes(value);
+}
+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;
+};
+exports.buildAccept = buildAccept;
+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 !== constants_1.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 === constants_1.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 === constants_1.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
+    };
+};
+exports.parseAcceptProfile = parseAcceptProfile;

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./envelope"), exports);
 __exportStar(require("./message"), exports);
 __exportStar(require("./did"), exports);
+__exportStar(require("./accept-profile"), exports);