@0xpolygonid/js-sdk 1.21.3 → 1.24.1

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

@@ -7,6 +7,7 @@ import { proving } from '@iden3/js-jwz';
 import { DID } from '@iden3/js-iden3-core';
 import * as uuid from 'uuid';
 import { AbstractMessageHandler } from './message-handler';
+import { verifyExpiresTime } from './common';
 /**
  *
  * Allows to handle Credential offer protocol message and return fetched credential
@@ -46,10 +47,34 @@ export class FetchHandler extends AbstractMessageHandler {
                 return this.handleFetchRequest(message);
             case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE:
                 return this.handleIssuanceResponseMsg(message);
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: {
+                const result = await this.handleOnchainOfferMessage(message);
+                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;
+            }
             default:
                 return super.handle(message, ctx);
         }
     }
+    async handleOnchainOfferMessage(offerMessage) {
+        if (!this.opts?.onchainIssuer) {
+            throw new Error('onchain issuer is not provided');
+        }
+        const credentials = [];
+        for (const credentialInfo of offerMessage.body.credentials) {
+            const issuerDID = DID.parse(offerMessage.from);
+            const userDID = DID.parse(offerMessage.to);
+            const credential = await this.opts.onchainIssuer.getCredential(issuerDID, userDID, BigInt(credentialInfo.id));
+            credentials.push(credential);
+        }
+        return credentials;
+    }
     async handleOfferMessage(offerMessage, ctx) {
         if (!ctx.mediaType) {
             ctx.mediaType = MediaType.ZKPMessage;
@@ -121,6 +146,9 @@ export class FetchHandler extends AbstractMessageHandler {
             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);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(offerMessage);
+        }
         const result = await this.handleOfferMessage(offerMessage, {
             mediaType: opts?.mediaType,
             headers: opts?.headers,
@@ -131,6 +159,14 @@ export class FetchHandler extends AbstractMessageHandler {
         }
         throw new Error('invalid protocol message response');
     }
+    /**
+     * Handles only messages with credentials/1.0/onchain-offer type
+     * @beta
+     */
+    async handleOnchainOffer(offer) {
+        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE);
+        return this.handleOnchainOfferMessage(offerMessage);
+    }
     async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
             throw new Error("failed request. empty 'to' field");
@@ -168,8 +204,11 @@ export class FetchHandler extends AbstractMessageHandler {
     /**
      * @inheritdoc IFetchHandler#handleCredentialFetchRequest
      */
-    async handleCredentialFetchRequest(envelope) {
+    async handleCredentialFetchRequest(envelope, opts) {
         const msgRequest = await FetchHandler.unpackMessage(this._packerMgr, envelope, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(msgRequest);
+        }
         const request = await this.handleFetchRequest(msgRequest);
         return this._packerMgr.pack(MediaType.PlainMessage, byteEncoder.encode(JSON.stringify(request)), {});
     }
@@ -186,8 +225,11 @@ export class FetchHandler extends AbstractMessageHandler {
     /**
      * @inheritdoc IFetchHandler#handleIssuanceResponseMessage
      */
-    async handleIssuanceResponseMessage(envelop) {
+    async handleIssuanceResponseMessage(envelop, opts) {
         const issuanceMsg = await FetchHandler.unpackMessage(this._packerMgr, envelop, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(issuanceMsg);
+        }
         await this.handleIssuanceResponseMsg(issuanceMsg);
         return Uint8Array.from([]);
     }

package/dist/node/esm/iden3comm/handlers/message-handler.js

@@ -1,5 +1,6 @@
 import { MediaType } from '../constants';
 import { proving } from '@iden3/js-jwz';
+import { verifyExpiresTime } from './common';
 /**
  * Base implementation of protocol message handler
  *
@@ -14,6 +15,9 @@ export class AbstractMessageHandler {
         return messageHandler;
     }
     async handle(message, context) {
+        if (!context.allowExpiredMessages) {
+            verifyExpiresTime(message);
+        }
         if (this.nextMessageHandler)
             return this.nextMessageHandler.handle(message, context);
         return Promise.reject('Message handler not provided or message not supported');

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, SupportedCurrencies, SupportedPaymentProofType } from '../../verifiable';
+import { ethers, parseEther, parseUnits } 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,82 @@ 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 convertedAmount = await convertPaymentAmount(data.amount, data.currency);
+    const paymentData = data.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+        ? {
+            recipient: data.recipient,
+            amount: convertedAmount,
+            expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
+            nonce: data.nonce,
+            metadata: '0x'
+        }
+        : {
+            tokenAddress: data.tokenAddress,
+            recipient: data.recipient,
+            amount: convertedAmount,
+            expirationDate: 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.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`);
+}
+export async function convertPaymentAmount(amount, currency) {
+    let convertedAmount = 0n;
+    switch (currency) {
+        case SupportedCurrencies.ETH:
+        case SupportedCurrencies.POL:
+        case SupportedCurrencies.MATIC:
+            convertedAmount = parseEther(amount.toString());
+            break;
+        case SupportedCurrencies.ETH_WEI:
+            convertedAmount = parseUnits(amount.toString(), 'wei');
+            break;
+        case SupportedCurrencies.ETH_GWEI:
+            convertedAmount = parseUnits(amount.toString(), 'gwei');
+            break;
+        case SupportedCurrencies.USDC:
+        case SupportedCurrencies.USDT: {
+            convertedAmount = parseUnits(amount.toString(), 6);
+            break;
+        }
+        default:
+            throw new Error(`failed request. unsupported currency ${currency}`);
+    }
+    return convertedAmount;
+}
 /**
  * @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 +115,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 +179,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 +233,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 +246,121 @@ 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 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 === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    ? {
+                        recipient,
+                        amount: convertedAmount,
+                        expirationDate: getUnixTimestamp(expirationDateRequired),
+                        nonce,
+                        metadata: '0x'
+                    }
+                    : {
+                        tokenAddress,
+                        recipient,
+                        amount: convertedAmount,
+                        expirationDate: 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: 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: expirationDateRequired.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 +374,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 {};