@0xpolygonid/js-sdk 1.21.3 → 1.24.1

package/dist/node/cjs/storage/interfaces/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./data-source"), exports);
 __exportStar(require("./circuits"), exports);
 __exportStar(require("./onchain-zkp-verifier"), exports);
 __exportStar(require("./onchain-revocation"), exports);
+__exportStar(require("./onchain-issuer"), exports);

package/dist/node/cjs/storage/interfaces/onchain-issuer.js

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

package/dist/node/cjs/utils/did-helper.js

@@ -72,7 +72,7 @@ const validateDIDDocumentAuth = async (did, resolverURL, state) => {
 };
 exports.validateDIDDocumentAuth = validateDIDDocumentAuth;
 const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
-    let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
+    let url = `${resolveURL}/${encodeURIComponent(did.string())}`;
     if (state) {
         url += `?state=${state.hex()}`;
     }
@@ -89,11 +89,11 @@ function emptyStateDID(did) {
     return emptyDID;
 }
 const resolveDidDocument = async (did, resolverUrl, opts) => {
-    let didString = did.string().replace(/:/g, '%3A');
+    let didString = encodeURIComponent(did.string());
     // for gist resolve we have to `hide` user did (look into resolver implementation)
     const isGistRequest = opts?.gist && !opts.state;
     if (isGistRequest) {
-        didString = emptyStateDID(did).string();
+        didString = encodeURIComponent(emptyStateDID(did).string());
     }
     let url = `${resolverUrl}/1.0/identifiers/${didString}`;
     if (opts?.signature) {

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisplayMethodType = exports.SupportedCurrencies = exports.PaymentType = exports.PaymentRequestDataType = exports.PaymentRequestType = exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
+exports.DisplayMethodType = exports.PaymentFeatures = exports.SupportedCurrencies = exports.SupportedPaymentProofType = exports.PaymentType = exports.PaymentRequestDataType = exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
 /** Verifiable constants */
 exports.VerifiableConstants = Object.freeze({
     ERRORS: {
@@ -115,15 +115,6 @@ var RefreshServiceType;
 (function (RefreshServiceType) {
     RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
 })(RefreshServiceType = exports.RefreshServiceType || (exports.RefreshServiceType = {}));
-/**
- * PaymentRequestType type for payment requests
- * @beta
- * @enum {string}
- */
-var PaymentRequestType;
-(function (PaymentRequestType) {
-    PaymentRequestType["PaymentRequest"] = "PaymentRequest";
-})(PaymentRequestType = exports.PaymentRequestType || (exports.PaymentRequestType = {}));
 /**
  * PaymentRequestDataType type for payment requests
  * @beta
@@ -132,6 +123,8 @@ var PaymentRequestType;
 var PaymentRequestDataType;
 (function (PaymentRequestDataType) {
     PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+    PaymentRequestDataType["Iden3PaymentRailsRequestV1"] = "Iden3PaymentRailsRequestV1";
+    PaymentRequestDataType["Iden3PaymentRailsERC20RequestV1"] = "Iden3PaymentRailsERC20RequestV1";
 })(PaymentRequestDataType = exports.PaymentRequestDataType || (exports.PaymentRequestDataType = {}));
 /**
  * PaymentType type for payment responses
@@ -141,17 +134,42 @@ var PaymentRequestDataType;
 var PaymentType;
 (function (PaymentType) {
     PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+    PaymentType["Iden3PaymentRailsV1"] = "Iden3PaymentRailsV1";
+    PaymentType["Iden3PaymentRailsERC20V1"] = "Iden3PaymentRailsERC20V1";
 })(PaymentType = exports.PaymentType || (exports.PaymentType = {}));
+/**
+ * SupportedPaymentProofType type for payment proofs
+ * @beta
+ * @enum {string}
+ */
+var SupportedPaymentProofType;
+(function (SupportedPaymentProofType) {
+    SupportedPaymentProofType["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(SupportedPaymentProofType = exports.SupportedPaymentProofType || (exports.SupportedPaymentProofType = {}));
 /**
  * Media types for Payment supported currencies
  * @beta
- * @enum {number}
+ * @enum {string}
  */
 var SupportedCurrencies;
 (function (SupportedCurrencies) {
     SupportedCurrencies["ETH"] = "ETH";
+    SupportedCurrencies["ETH_WEI"] = "ETHWEI";
+    SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
+    SupportedCurrencies["POL"] = "POL";
+    SupportedCurrencies["USDT"] = "USDT";
+    SupportedCurrencies["USDC"] = "USDC";
 })(SupportedCurrencies = exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
+/**
+ * Supported features for payment-request
+ * @beta
+ * @enum {string}
+ */
+var PaymentFeatures;
+(function (PaymentFeatures) {
+    PaymentFeatures["EIP_2612"] = "EIP-2612";
+})(PaymentFeatures = exports.PaymentFeatures || (exports.PaymentFeatures = {}));
 /**
  * DisplayMethodType type for display method
  *

package/dist/node/cjs/verifiable/credential.js

@@ -51,6 +51,92 @@ class W3CCredential {
         this.credentialSubject = {};
         this.issuer = '';
     }
+    /**
+     *
+     * @param issuer - DID of the issuer
+     * @param request - Credential request
+     * @returns - W3C Credential
+     */
+    static fromCredentialRequest(issuer, request) {
+        if (!request.id) {
+            throw new Error('Credential id is required');
+        }
+        if (!request.context) {
+            throw new Error('Credential context is required');
+        }
+        const context = [
+            constants_1.VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
+            constants_1.VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
+            ...request.context
+        ];
+        const credentialType = [
+            constants_1.VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
+            request.type
+        ];
+        const credentialSubject = request.credentialSubject;
+        credentialSubject['type'] = request.type;
+        const cr = new W3CCredential();
+        cr.id = request.id;
+        cr['@context'] = context;
+        cr.type = credentialType;
+        cr.credentialSubject = credentialSubject;
+        cr.issuer = issuer.string();
+        cr.credentialSchema = {
+            id: request.credentialSchema,
+            type: constants_1.VerifiableConstants.JSON_SCHEMA_VALIDATOR
+        };
+        cr.credentialStatus = W3CCredential.buildCredentialStatus(request, issuer);
+        request.expiration && (cr.expirationDate = new Date(request.expiration).toISOString());
+        request.refreshService && (cr.refreshService = request.refreshService);
+        request.displayMethod && (cr.displayMethod = request.displayMethod);
+        request.issuanceDate && (cr.issuanceDate = new Date(request.issuanceDate).toISOString());
+        return cr;
+    }
+    /**
+     * Builds credential status
+     * @param {CredentialRequest} request
+     * @returns `CredentialStatus`
+     */
+    static buildCredentialStatus(request, issuer) {
+        const credentialStatus = {
+            id: request.revocationOpts.id,
+            type: request.revocationOpts.type,
+            revocationNonce: request.revocationOpts.nonce
+        };
+        switch (request.revocationOpts.type) {
+            case constants_1.CredentialStatusType.SparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
+                };
+            case constants_1.CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: request.revocationOpts.issuerState
+                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
+                        : `${credentialStatus.id.replace(/\/$/, '')}`
+                };
+            case constants_1.CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
+                const issuerId = js_iden3_core_1.DID.idFromDID(issuer);
+                const chainId = (0, js_iden3_core_1.getChainId)(js_iden3_core_1.DID.blockchainFromId(issuerId), js_iden3_core_1.DID.networkIdFromId(issuerId));
+                const searchParams = [
+                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
+                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
+                    ['state', request.revocationOpts.issuerState || '']
+                ]
+                    .filter(([, value]) => Boolean(value))
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join('&');
+                return {
+                    ...credentialStatus,
+                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
+                    id: `${issuer.string()}/credentialStatus?${searchParams}`
+                };
+            }
+            default:
+                return credentialStatus;
+        }
+    }
     toJSON() {
         return {
             ...this,

package/dist/node/esm/credentials/credential-wallet.js

@@ -1,4 +1,4 @@
-import { DID, getChainId } from '@iden3/js-iden3-core';
+import { DID } from '@iden3/js-iden3-core';
 import { W3CCredential, VerifiableConstants, CredentialStatusType, DisplayMethodType } from './../verifiable';
 import * as uuid from 'uuid';
 import { CredentialStatusResolverRegistry } from './status/resolver';
@@ -31,40 +31,18 @@ export class CredentialWallet {
             if (!schema.$metadata.uris['jsonLdContext']) {
                 throw new Error('jsonLdContext is missing is the schema');
             }
-            request.context = request.context ?? [];
-            if (request.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
-                !request.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)) {
-                request.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
+            // do copy of request to avoid mutation
+            const r = { ...request };
+            r.context = r.context ?? [];
+            if (r.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
+                !r.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)) {
+                r.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
             }
-            const context = [
-                VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
-                ...request.context,
-                VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
-                schema.$metadata.uris['jsonLdContext']
-            ];
-            const credentialType = [
-                VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
-                request.type
-            ];
-            const expirationDate = !request.expiration || request.expiration == 0 ? null : request.expiration;
-            const credentialSubject = request.credentialSubject;
-            credentialSubject['type'] = request.type;
-            const cr = new W3CCredential();
-            cr.id = `urn:${uuid.v4()}`;
-            cr['@context'] = context;
-            cr.type = credentialType;
-            cr.expirationDate = expirationDate ? new Date(expirationDate * 1000).toISOString() : undefined;
-            cr.refreshService = request.refreshService;
-            cr.displayMethod = request.displayMethod;
-            cr.issuanceDate = new Date().toISOString();
-            cr.credentialSubject = credentialSubject;
-            cr.issuer = issuer.string();
-            cr.credentialSchema = {
-                id: request.credentialSchema,
-                type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
-            };
-            cr.credentialStatus = this.buildCredentialStatus(request, issuer);
-            return cr;
+            r.context.push(schema.$metadata.uris['jsonLdContext']);
+            r.expiration = r.expiration ? r.expiration * 1000 : undefined;
+            r.id = r.id ? r.id : `urn:${uuid.v4()}`;
+            r.issuanceDate = r.issuanceDate ? r.issuanceDate * 1000 : Date.now();
+            return W3CCredential.fromCredentialRequest(issuer, r);
         };
         // if no credential status resolvers are provided
         // register default issuer resolver
@@ -134,51 +112,6 @@ export class CredentialWallet {
         }
         return statusResolver.resolve(credStatus, credentialStatusResolveOptions);
     }
-    /**
-     * Builds credential status
-     * @param {CredentialRequest} request
-     * @returns `CredentialStatus`
-     */
-    buildCredentialStatus(request, issuer) {
-        const credentialStatus = {
-            id: request.revocationOpts.id,
-            type: request.revocationOpts.type,
-            revocationNonce: request.revocationOpts.nonce
-        };
-        switch (request.revocationOpts.type) {
-            case CredentialStatusType.SparseMerkleTreeProof:
-                return {
-                    ...credentialStatus,
-                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
-                };
-            case CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
-                return {
-                    ...credentialStatus,
-                    id: request.revocationOpts.issuerState
-                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
-                        : `${credentialStatus.id.replace(/\/$/, '')}`
-                };
-            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
-                const issuerId = DID.idFromDID(issuer);
-                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
-                const searchParams = [
-                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
-                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
-                    ['state', request.revocationOpts.issuerState || '']
-                ]
-                    .filter(([, value]) => Boolean(value))
-                    .map(([key, value]) => `${key}=${value}`)
-                    .join('&');
-                return {
-                    ...credentialStatus,
-                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
-                    id: `${issuer.string()}/credentialStatus?${searchParams}`
-                };
-            }
-            default:
-                return credentialStatus;
-        }
-    }
     /**
      * {@inheritDoc ICredentialWallet.findById}
      */

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

@@ -4,6 +4,7 @@ export * from './status/sparse-merkle-tree';
 export * from './status/resolver';
 export * from './status/agent-revocation';
 export * from './status/credential-status-publisher';
+export * from './status/did-resolver-revocation';
 export * from './credential-wallet';
 export * from './rhs';
 export * from './utils';

package/dist/node/esm/credentials/status/did-resolver-revocation.js

@@ -0,0 +1,17 @@
+export class DidDocumentCredentialStatusResolver {
+    constructor(didResolverUrl) {
+        this.didResolverUrl = didResolverUrl;
+    }
+    async resolve(credentialStatus, opts) {
+        if (!opts?.issuerDID) {
+            throw new Error('IssuerDID is not set in options');
+        }
+        const url = `${this.didResolverUrl}/1.0/credential-status/${encodeURIComponent(opts.issuerDID.string())}`;
+        const resp = await fetch(url, {
+            method: 'POST',
+            body: JSON.stringify(credentialStatus)
+        });
+        const data = await resp.json();
+        return data;
+    }
+}

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

@@ -73,5 +73,29 @@ export const SUPPORTED_PUBLIC_KEY_TYPES = {
         'JsonWebKey2020'
     ]
 };
+export var ProtocolVersion;
+(function (ProtocolVersion) {
+    ProtocolVersion["V1"] = "iden3comm/v1";
+})(ProtocolVersion || (ProtocolVersion = {}));
+export var AcceptAuthCircuits;
+(function (AcceptAuthCircuits) {
+    AcceptAuthCircuits["AuthV2"] = "authV2";
+    AcceptAuthCircuits["AuthV3"] = "authV3";
+})(AcceptAuthCircuits || (AcceptAuthCircuits = {}));
+export var AcceptJwzAlgorithms;
+(function (AcceptJwzAlgorithms) {
+    AcceptJwzAlgorithms["Groth16"] = "groth16";
+})(AcceptJwzAlgorithms || (AcceptJwzAlgorithms = {}));
+export var AcceptJwsAlgorithms;
+(function (AcceptJwsAlgorithms) {
+    AcceptJwsAlgorithms["ES256K"] = "ES256K";
+    AcceptJwsAlgorithms["ES256KR"] = "ES256K-R";
+})(AcceptJwsAlgorithms || (AcceptJwsAlgorithms = {}));
+export const defaultAcceptProfile = {
+    protocolVersion: ProtocolVersion.V1,
+    env: MediaType.ZKPMessage,
+    circuits: [AcceptAuthCircuits.AuthV2],
+    alg: [AcceptJwzAlgorithms.Groth16]
+};
 export const DEFAULT_PROOF_VERIFY_DELAY = 1 * 60 * 60 * 1000; // 1 hour
 export const DEFAULT_AUTH_VERIFY_DELAY = 5 * 60 * 1000; // 5 minutes

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

@@ -1,21 +1,23 @@
-import { MediaType } from '../constants';
+import { MediaType, ProtocolVersion } from '../constants';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
-import { DID } from '@iden3/js-iden3-core';
+import { DID, getUnixTimestamp } from '@iden3/js-iden3-core';
 import { proving } from '@iden3/js-jwz';
 import * as uuid from 'uuid';
 import { byteDecoder, byteEncoder } from '../../utils';
-import { processZeroKnowledgeProofRequests } from './common';
+import { processZeroKnowledgeProofRequests, verifyExpiresTime } from './common';
 import { CircuitId } from '../../circuits';
 import { AbstractMessageHandler } from './message-handler';
+import { parseAcceptProfile } from '../utils';
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
  * @param {string} sender - sender did
  * @param {string} callbackUrl - callback that user should use to send response
+ * @param {AuthorizationRequestCreateOptions} opts - authorization request options
  * @returns `Promise<AuthorizationRequestMessage>`
  */
-export function createAuthorizationRequest(reason, sender, callbackUrl) {
-    return createAuthorizationRequestWithMessage(reason, '', sender, callbackUrl);
+export function createAuthorizationRequest(reason, sender, callbackUrl, opts) {
+    return createAuthorizationRequestWithMessage(reason, '', sender, callbackUrl, opts);
 }
 /**
  *  createAuthorizationRequestWithMessage is a function to create protocol authorization request with explicit message to sign
@@ -23,9 +25,10 @@ export function createAuthorizationRequest(reason, sender, callbackUrl) {
  * @param {string} message - message to sign in the response
  * @param {string} sender - sender did
  * @param {string} callbackUrl - callback that user should use to send response
+ * @param {AuthorizationRequestCreateOptions} opts - authorization request options
  * @returns `Promise<AuthorizationRequestMessage>`
  */
-export function createAuthorizationRequestWithMessage(reason, message, sender, callbackUrl) {
+export function createAuthorizationRequestWithMessage(reason, message, sender, callbackUrl, opts) {
     const uuidv4 = uuid.v4();
     const request = {
         id: uuidv4,
@@ -34,11 +37,14 @@ export function createAuthorizationRequestWithMessage(reason, message, sender, c
         typ: MediaType.PlainMessage,
         type: PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE,
         body: {
+            accept: opts?.accept,
             reason: reason,
             message: message,
             callbackUrl: callbackUrl,
-            scope: []
-        }
+            scope: opts?.scope ?? []
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -97,17 +103,18 @@ export class AuthHandler extends AbstractMessageHandler {
         }
         // override sender did if it's explicitly specified in the auth request
         const to = authRequest.to ? DID.parse(authRequest.to) : ctx.senderDid;
-        const mediaType = ctx.mediaType || MediaType.ZKPMessage;
         const guid = uuid.v4();
         if (!authRequest.from) {
             throw new Error('auth request should contain from field');
         }
+        const responseType = PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE;
+        const mediaType = this.getSupportedMediaTypeByProfile(ctx, responseType, authRequest.body.accept);
         const from = DID.parse(authRequest.from);
         const responseScope = await processZeroKnowledgeProofRequests(to, authRequest?.body.scope, from, this._proofService, { mediaType, supportedCircuits: this._supportedCircuits });
         return {
             id: guid,
-            typ: ctx.mediaType,
-            type: PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE,
+            typ: mediaType,
+            type: responseType,
             thid: authRequest.thid ?? guid,
             body: {
                 message: authRequest?.body?.message,
@@ -122,6 +129,9 @@ export class AuthHandler extends AbstractMessageHandler {
      */
     async handleAuthorizationRequest(did, request, opts) {
         const authRequest = await this.parseAuthorizationRequest(request);
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(authRequest);
+        }
         if (!opts) {
             opts = {
                 mediaType: MediaType.ZKPMessage
@@ -211,6 +221,9 @@ export class AuthHandler extends AbstractMessageHandler {
      * @inheritdoc IAuthHandler#handleAuthorizationResponse
      */
     async handleAuthorizationResponse(response, request, opts) {
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(response);
+        }
         const authResp = (await this.handleAuthResponse(response, {
             request,
             acceptedStateTransitionDelay: opts?.acceptedStateTransitionDelay,
@@ -244,4 +257,35 @@ export class AuthHandler extends AbstractMessageHandler {
             }
         }
     }
+    getSupportedMediaTypeByProfile(ctx, responseType, profile) {
+        let mediaType;
+        if (profile?.length) {
+            const supportedMediaTypes = [];
+            for (const acceptProfile of profile) {
+                // 1. check protocol version
+                const { protocolVersion, env } = parseAcceptProfile(acceptProfile);
+                const responseTypeVersion = Number(responseType.split('/').at(-2));
+                if (protocolVersion !== ProtocolVersion.V1 ||
+                    (protocolVersion === ProtocolVersion.V1 &&
+                        (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
+                    continue;
+                }
+                // 2. check packer support
+                if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
+                    supportedMediaTypes.push(env);
+                }
+            }
+            if (!supportedMediaTypes.length) {
+                throw new Error('no packer with profile which meets `accept` header requirements');
+            }
+            mediaType = supportedMediaTypes[0];
+            if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
+                mediaType = ctx.mediaType;
+            }
+        }
+        else {
+            mediaType = ctx.mediaType || MediaType.ZKPMessage;
+        }
+        return mediaType;
+    }
 }

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

@@ -1,5 +1,6 @@
 import { getRandomBytes } from '@iden3/js-crypto';
 import { mergeObjects } from '../../utils';
+import { getUnixTimestamp } from '@iden3/js-iden3-core';
 /**
  * Groups the ZeroKnowledgeProofRequest objects based on their groupId.
  * Returns a Map where the key is the groupId and the value is an object containing the query and linkNonce.
@@ -79,3 +80,13 @@ export const processZeroKnowledgeProofRequests = async (to, requests, from, proo
     }
     return zkpResponses;
 };
+/**
+ * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
+ *
+ * @param message - Basic message to verify.
+ */
+export const verifyExpiresTime = (message) => {
+    if (message?.expires_time && message.expires_time < getUnixTimestamp(new Date())) {
+        throw new Error('Message expired');
+    }
+};

package/dist/node/esm/iden3comm/handlers/contract-request.js

@@ -1,8 +1,8 @@
 import { CircuitId } from '../../circuits/models';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
-import { DID, ChainIds } from '@iden3/js-iden3-core';
+import { DID, ChainIds, getUnixTimestamp } from '@iden3/js-iden3-core';
 import { FunctionSignatures } from '../../storage';
-import { processZeroKnowledgeProofRequests } from './common';
+import { processZeroKnowledgeProofRequests, verifyExpiresTime } from './common';
 import { AbstractMessageHandler } from './message-handler';
 /**
  *
@@ -107,7 +107,8 @@ export class ContractRequestHandler extends AbstractMessageHandler {
             body: {
                 transaction_data: request.body.transaction_data,
                 scope: []
-            }
+            },
+            created_time: getUnixTimestamp(new Date())
         };
         for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
             for (const zkpResponse of zkpResponses) {
@@ -131,6 +132,9 @@ export class ContractRequestHandler extends AbstractMessageHandler {
      */
     async handleContractInvokeRequest(did, request, opts) {
         const ciRequest = await this.parseContractInvokeRequest(request);
+        if (!opts.allowExpiredMessages) {
+            verifyExpiresTime(ciRequest);
+        }
         if (ciRequest.body.transaction_data.method_id !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`please use handle method to work with other method ids`);
         }

package/dist/node/esm/iden3comm/handlers/credential-proposal.js

@@ -1,9 +1,10 @@
 import { PROTOCOL_MESSAGE_TYPE, 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 { verifyExpiresTime } from './common';
 /**
  * @beta
  * createProposalRequest is a function to create protocol proposal-request protocol message
@@ -21,7 +22,9 @@ export function createProposalRequest(sender, receiver, opts) {
         to: receiver.string(),
         typ: MediaType.PlainMessage,
         type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_REQUEST_MESSAGE_TYPE,
-        body: opts
+        body: opts,
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -33,7 +36,7 @@ export function createProposalRequest(sender, receiver, opts) {
  * @param {Proposal[]} proposals - proposals
  * @returns `Promise<ProposalRequestMessage>`
  */
-export function createProposal(sender, receiver, proposals) {
+export function createProposal(sender, receiver, proposals, opts) {
     const uuidv4 = uuid.v4();
     const request = {
         id: uuidv4,
@@ -44,7 +47,9 @@ export function createProposal(sender, receiver, proposals) {
         type: PROTOCOL_MESSAGE_TYPE.PROPOSAL_MESSAGE_TYPE,
         body: {
             proposals: proposals || []
-        }
+        },
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time ? getUnixTimestamp(opts.expires_time) : undefined
     };
     return request;
 }
@@ -182,6 +187,9 @@ export class CredentialProposalHandler extends AbstractMessageHandler {
         if (!proposalRequest.from) {
             throw new Error(`failed request. empty 'from' field`);
         }
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(proposalRequest);
+        }
         const senderDID = DID.parse(proposalRequest.from);
         const message = await this.handleProposalRequestMessage(proposalRequest);
         const response = byteEncoder.encode(JSON.stringify(message));
@@ -199,6 +207,9 @@ export class CredentialProposalHandler extends AbstractMessageHandler {
      * @inheritdoc ICredentialProposalHandler#handleProposal
      */
     async handleProposal(proposal, opts) {
+        if (!opts?.allowExpiredMessages) {
+            verifyExpiresTime(proposal);
+        }
         if (opts?.proposalRequest && opts.proposalRequest.from !== proposal.to) {
             throw new Error(`sender of the request is not a target of response - expected ${opts.proposalRequest.from}, given ${proposal.to}`);
         }