@0xpolygonid/js-sdk 1.21.3 → 1.24.1

package/dist/node/esm/storage/blockchain/onchain-zkp-verifier.js

@@ -37,23 +37,8 @@ export class OnChainZKPVerifier {
     constructor(_configs, _opts) {
         this._configs = _configs;
         this._opts = _opts;
-        /**
-         * supported circuits
-         */
-        this._supportedCircuits = [
-            CircuitId.AtomicQueryMTPV2OnChain,
-            CircuitId.AtomicQuerySigV2OnChain,
-            CircuitId.AtomicQueryV3OnChain
-        ];
-        /**
-         * abi coder to encode/decode structures to solidity bytes
-         */
-        this._abiCoder = new ethers.AbiCoder();
     }
-    /**
-     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
-     */
-    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+    static async prepareTxArgsSubmitV1(txData, zkProofResponse) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
         }
@@ -71,6 +56,12 @@ export class OnChainZKPVerifier {
         ];
         return payload;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+    }
     /**
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
@@ -160,13 +151,10 @@ export class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
-    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+    static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
             throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
         }
-        if (!this._opts?.didResolverUrl) {
-            throw new Error(`did resolver url required for crosschain verification`);
-        }
         const gistUpdateArr = [];
         const stateUpdateArr = [];
         const payload = [];
@@ -191,7 +179,9 @@ export class OnChainZKPVerifier {
                     continue;
                 }
                 gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
+                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), resolverUrl, {
+                    gist: gist.root
+                }));
             }
             const stateUpdateResolutions = [];
             for (const state of stateInfo.states) {
@@ -200,7 +190,7 @@ export class OnChainZKPVerifier {
                     continue;
                 }
                 stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), this._opts.didResolverUrl, {
+                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), resolverUrl, {
                     state: state.state
                 }));
             }
@@ -234,10 +224,16 @@ export class OnChainZKPVerifier {
         const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
         return [payload, crossChainProofs];
     }
-    packZkpProof(inputs, a, b, c) {
-        return this._abiCoder.encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
+    }
+    static packZkpProof(inputs, a, b, c) {
+        return new ethers.AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
     }
-    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+    static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
         for (const globalStateUpdate of gistUpdateArr) {
             proofs.push({
@@ -251,10 +247,10 @@ export class OnChainZKPVerifier {
                 proof: this.packIdentityStateMsg(stateUpdate)
             });
         }
-        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+        return new ethers.AbiCoder().encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
     }
-    packGlobalStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packGlobalStateMsg(msg) {
+        return new ethers.AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -266,8 +262,8 @@ export class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packIdentityStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packIdentityStateMsg(msg) {
+        return new ethers.AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -279,10 +275,10 @@ export class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packMetadatas(metas) {
-        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    static packMetadatas(metas) {
+        return new ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
-    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+    static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
         let atomicQueryPubSignals;
         switch (onChainCircuitId) {
             case CircuitId.AtomicQueryMTPV2OnChain:
@@ -299,7 +295,7 @@ export class OnChainZKPVerifier {
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
     }
-    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+    static async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
         const didDoc = await resolveDidDocument(did, resolverUrl, {
             ...opts,
             signature: DIDDocumentSignature.EthereumEip712Signature2021
@@ -332,3 +328,11 @@ export class OnChainZKPVerifier {
         };
     }
 }
+/**
+ * supported circuits
+ */
+OnChainZKPVerifier._supportedCircuits = [
+    CircuitId.AtomicQueryMTPV2OnChain,
+    CircuitId.AtomicQuerySigV2OnChain,
+    CircuitId.AtomicQueryV3OnChain
+];

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

@@ -7,3 +7,4 @@ export * from './data-source';
 export * from './circuits';
 export * from './onchain-zkp-verifier';
 export * from './onchain-revocation';
+export * from './onchain-issuer';

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

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

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

@@ -65,7 +65,7 @@ export const validateDIDDocumentAuth = async (did, resolverURL, state) => {
     }
 };
 export 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()}`;
     }
@@ -81,11 +81,11 @@ function emptyStateDID(did) {
     return emptyDID;
 }
 export 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/esm/verifiable/constants.js

@@ -112,15 +112,6 @@ export var RefreshServiceType;
 (function (RefreshServiceType) {
     RefreshServiceType["Iden3RefreshService2023"] = "Iden3RefreshService2023";
 })(RefreshServiceType || (RefreshServiceType = {}));
-/**
- * PaymentRequestType type for payment requests
- * @beta
- * @enum {string}
- */
-export var PaymentRequestType;
-(function (PaymentRequestType) {
-    PaymentRequestType["PaymentRequest"] = "PaymentRequest";
-})(PaymentRequestType || (PaymentRequestType = {}));
 /**
  * PaymentRequestDataType type for payment requests
  * @beta
@@ -129,6 +120,8 @@ export var PaymentRequestType;
 export var PaymentRequestDataType;
 (function (PaymentRequestDataType) {
     PaymentRequestDataType["Iden3PaymentRequestCryptoV1"] = "Iden3PaymentRequestCryptoV1";
+    PaymentRequestDataType["Iden3PaymentRailsRequestV1"] = "Iden3PaymentRailsRequestV1";
+    PaymentRequestDataType["Iden3PaymentRailsERC20RequestV1"] = "Iden3PaymentRailsERC20RequestV1";
 })(PaymentRequestDataType || (PaymentRequestDataType = {}));
 /**
  * PaymentType type for payment responses
@@ -138,17 +131,42 @@ export var PaymentRequestDataType;
 export var PaymentType;
 (function (PaymentType) {
     PaymentType["Iden3PaymentCryptoV1"] = "Iden3PaymentCryptoV1";
+    PaymentType["Iden3PaymentRailsV1"] = "Iden3PaymentRailsV1";
+    PaymentType["Iden3PaymentRailsERC20V1"] = "Iden3PaymentRailsERC20V1";
 })(PaymentType || (PaymentType = {}));
+/**
+ * SupportedPaymentProofType type for payment proofs
+ * @beta
+ * @enum {string}
+ */
+export var SupportedPaymentProofType;
+(function (SupportedPaymentProofType) {
+    SupportedPaymentProofType["EthereumEip712Signature2021"] = "EthereumEip712Signature2021";
+})(SupportedPaymentProofType || (SupportedPaymentProofType = {}));
 /**
  * Media types for Payment supported currencies
  * @beta
- * @enum {number}
+ * @enum {string}
  */
 export 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 || (SupportedCurrencies = {}));
+/**
+ * Supported features for payment-request
+ * @beta
+ * @enum {string}
+ */
+export var PaymentFeatures;
+(function (PaymentFeatures) {
+    PaymentFeatures["EIP_2612"] = "EIP-2612";
+})(PaymentFeatures || (PaymentFeatures = {}));
 /**
  * DisplayMethodType type for display method
  *

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

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { BJJSignatureProof2021, Iden3SparseMerkleTreeProof } from './proof';
-import { Claim, DID, MerklizedRootPosition as MerklizedRootPositionCore, IdPosition, ClaimOptions } from '@iden3/js-iden3-core';
+import { Claim, DID, MerklizedRootPosition as MerklizedRootPositionCore, IdPosition, ClaimOptions, getChainId } from '@iden3/js-iden3-core';
 import { Hash, rootFromProof, verifyProof } from '@iden3/js-merkletree';
 import { Merklizer } from '@iden3/js-jsonld-merklization';
 import { PublicKey, poseidon } from '@iden3/js-crypto';
 import { getUserDIDFromCredential } from '../credentials/utils';
 import { byteEncoder, validateDIDDocumentAuth } from '../utils';
-import { MerklizedRootPosition, ProofType, SubjectPosition } from './constants';
+import { CredentialStatusType, MerklizedRootPosition, ProofType, SubjectPosition, VerifiableConstants } from './constants';
 import { calculateCoreSchemaHash, findCredentialType, parseCoreClaimSlots } from './core-utils';
 import * as jsonld from 'jsonld/lib';
 import * as ldcontext from 'jsonld/lib/context';
@@ -25,6 +25,92 @@ export 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 = [
+            VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
+            VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
+            ...request.context
+        ];
+        const credentialType = [
+            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: 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 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;
+        }
+    }
     toJSON() {
         return {
             ...this,

package/dist/types/credentials/credential-wallet.d.ts

@@ -160,12 +160,6 @@ export declare class CredentialWallet implements ICredentialWallet {
      * {@inheritDoc ICredentialWallet.createCredential}
      */
     createCredential: (issuer: DID, request: CredentialRequest, schema: JSONSchema) => W3CCredential;
-    /**
-     * Builds credential status
-     * @param {CredentialRequest} request
-     * @returns `CredentialStatus`
-     */
-    private buildCredentialStatus;
     /**
      * {@inheritDoc ICredentialWallet.findById}
      */

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

@@ -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/types/credentials/models.d.ts

@@ -15,6 +15,10 @@ export type PublishMode = 'sync' | 'async' | 'callback';
  * @interface CredentialRequest
  */
 export interface CredentialRequest {
+    /**
+     * Credential ID
+     */
+    id?: string;
     /**
      * JSON credential schema
      */
@@ -55,6 +59,10 @@ export interface CredentialRequest {
      * merklizedRootPosition (index / value / none)
      */
     merklizedRootPosition?: MerklizedRootPosition;
+    /**
+     * issuance Date
+     */
+    issuanceDate?: number;
     /**
      * Revocation options
      *

package/dist/types/credentials/status/did-resolver-revocation.d.ts

@@ -0,0 +1,7 @@
+import { CredentialStatus, RevocationStatus } from '../../verifiable';
+import { CredentialStatusResolveOptions, CredentialStatusResolver } from './resolver';
+export declare class DidDocumentCredentialStatusResolver implements CredentialStatusResolver {
+    private readonly didResolverUrl;
+    constructor(didResolverUrl: string);
+    resolve(credentialStatus: CredentialStatus, opts?: CredentialStatusResolveOptions | undefined): Promise<RevocationStatus>;
+}

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

@@ -1,3 +1,4 @@
+import { AcceptProfile } from './types';
 /**
  * Constants for Iden3 protocol
  */
@@ -37,5 +38,20 @@ export declare const SUPPORTED_PUBLIC_KEY_TYPES: {
     ES256K: string[];
     'ES256K-R': string[];
 };
+export declare enum ProtocolVersion {
+    V1 = "iden3comm/v1"
+}
+export declare enum AcceptAuthCircuits {
+    AuthV2 = "authV2",
+    AuthV3 = "authV3"
+}
+export declare enum AcceptJwzAlgorithms {
+    Groth16 = "groth16"
+}
+export declare enum AcceptJwsAlgorithms {
+    ES256K = "ES256K",
+    ES256KR = "ES256K-R"
+}
+export declare const defaultAcceptProfile: AcceptProfile;
 export declare const DEFAULT_PROOF_VERIFY_DELAY: number;
 export declare const DEFAULT_AUTH_VERIFY_DELAY: number;

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

@@ -1,32 +1,43 @@
 import { MediaType } from '../constants';
 import { IProofService } from '../../proof/proof-service';
-import { StateVerificationOpts, AuthorizationRequestMessage, AuthorizationResponseMessage, BasicMessage, IPackageManager, JWSPackerParams } from '../types';
+import { StateVerificationOpts, AuthorizationRequestMessage, AuthorizationResponseMessage, BasicMessage, IPackageManager, JWSPackerParams, ZeroKnowledgeProofRequest } from '../types';
 import { DID } from '@iden3/js-iden3-core';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
+/**
+ * Options to pass to createAuthorizationRequest function
+ * @public
+ */
+export type AuthorizationRequestCreateOptions = {
+    accept?: string[];
+    scope?: ZeroKnowledgeProofRequest[];
+    expires_time?: Date;
+};
 /**
  *  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 declare function createAuthorizationRequest(reason: string, sender: string, callbackUrl: string): AuthorizationRequestMessage;
+export declare function createAuthorizationRequest(reason: string, sender: string, callbackUrl: string, opts?: AuthorizationRequestCreateOptions): AuthorizationRequestMessage;
 /**
  *  createAuthorizationRequestWithMessage is a function to create protocol authorization request with explicit message to sign
  * @param {string} reason - reason to request proof
  * @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 declare function createAuthorizationRequestWithMessage(reason: string, message: string, sender: string, callbackUrl: string): AuthorizationRequestMessage;
+export declare function createAuthorizationRequestWithMessage(reason: string, message: string, sender: string, callbackUrl: string, opts?: AuthorizationRequestCreateOptions): AuthorizationRequestMessage;
 /**
  *
  * Options to pass to auth response handler
  *
  * @public
  */
-export type AuthResponseHandlerOptions = StateVerificationOpts & {
+export type AuthResponseHandlerOptions = StateVerificationOpts & BasicHandlerOptions & {
     acceptedProofGenerationDelay?: number;
 };
 /**
@@ -92,10 +103,10 @@ export type AuthMessageHandlerOptions = AuthReqOptions | AuthRespOptions;
  * @public
  * @interface AuthHandlerOptions
  */
-export interface AuthHandlerOptions {
+export type AuthHandlerOptions = BasicHandlerOptions & {
     mediaType: MediaType;
     packerOptions?: JWSPackerParams;
-}
+};
 /**
  *
  * Allows to process AuthorizationRequest protocol message and produce JWZ response.
@@ -139,5 +150,6 @@ export declare class AuthHandler extends AbstractMessageHandler implements IAuth
         response: AuthorizationResponseMessage;
     }>;
     private verifyAuthRequest;
+    private getSupportedMediaTypeByProfile;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
+import { BasicMessage, JWSPackerParams, ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { IProofService } from '../../proof';
 import { CircuitId } from '../../circuits';
@@ -21,3 +21,9 @@ export declare const processZeroKnowledgeProofRequests: (to: DID, requests: Zero
     ethSigner?: Signer;
     challenge?: bigint;
 }) => Promise<ZeroKnowledgeProofResponse[]>;
+/**
+ * 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 declare const verifyExpiresTime: (message: BasicMessage) => void;

package/dist/types/iden3comm/handlers/contract-request.d.ts

@@ -4,7 +4,7 @@ import { ContractInvokeRequest } from '../types/protocol/contract-request';
 import { DID } from '@iden3/js-iden3-core';
 import { IOnChainZKPVerifier } from '../../storage';
 import { Signer } from 'ethers';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 /**
  * Interface that allows the processing of the contract request
  *
@@ -30,7 +30,7 @@ export interface IContractRequestHandler {
     handleContractInvokeRequest(did: DID, request: Uint8Array, opts?: ContractInvokeHandlerOptions): Promise<Map<string, ZeroKnowledgeProofResponse>>;
 }
 /** ContractInvokeHandlerOptions represents contract invoke handler options */
-export type ContractInvokeHandlerOptions = {
+export type ContractInvokeHandlerOptions = BasicHandlerOptions & {
     ethSigner: Signer;
     challenge?: bigint;
 };

package/dist/types/iden3comm/handlers/credential-proposal.d.ts

@@ -2,7 +2,7 @@ import { BasicMessage, DIDDocument, IPackageManager, JsonDocumentObject, PackerP
 import { DID } from '@iden3/js-iden3-core';
 import { Proposal, ProposalRequestCredential, ProposalRequestMessage, ProposalMessage } from '../types/protocol/proposal-request';
 import { IIdentityWallet } from '../../identity';
-import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
 /** @beta ProposalRequestCreationOptions represents proposal-request creation options */
 export type ProposalRequestCreationOptions = {
     credentials: ProposalRequestCredential[];
@@ -11,6 +11,11 @@ export type ProposalRequestCreationOptions = {
         data?: JsonDocumentObject;
     };
     did_doc?: DIDDocument;
+    expires_time?: Date;
+};
+/** @beta ProposalCreationOptions represents proposal creation options */
+export type ProposalCreationOptions = {
+    expires_time?: Date;
 };
 /**
  * @beta
@@ -29,7 +34,7 @@ export declare function createProposalRequest(sender: DID, receiver: DID, opts:
  * @param {Proposal[]} proposals - proposals
  * @returns `Promise<ProposalRequestMessage>`
  */
-export declare function createProposal(sender: DID, receiver: DID, proposals?: Proposal[]): ProposalMessage;
+export declare function createProposal(sender: DID, receiver: DID, proposals?: Proposal[], opts?: ProposalCreationOptions): ProposalMessage;
 /**
  * @beta
  * Interface that allows the processing of the proposal-request
@@ -66,9 +71,9 @@ export interface ICredentialProposalHandler {
     }>;
 }
 /** @beta ProposalRequestHandlerOptions represents proposal-request handler options */
-export type ProposalRequestHandlerOptions = object;
+export type ProposalRequestHandlerOptions = BasicHandlerOptions;
 /** @beta ProposalHandlerOptions represents proposal handler options */
-export type ProposalHandlerOptions = {
+export type ProposalHandlerOptions = BasicHandlerOptions & {
     proposalRequest?: ProposalRequestMessage;
 };
 /** @beta CredentialProposalHandlerParams represents credential proposal handler params */