@0xpolygonid/js-sdk 1.21.3 → 1.23.0

package/dist/node/cjs/storage/blockchain/erc20-permit-sig.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermitSignature = void 0;
+const ethers_1 = require("ethers");
+const ERC20Permit_json_1 = __importDefault(require("./abi/ERC20Permit.json"));
+/**
+ * @beta
+ * getPermitSignature is a function to create EIP712 Permit signature
+ * @param {Signer} signer - User who owns the tokens
+ * @param {string} tokenAddress - EIP-2612 contract address
+ * @param {string} spender -  The contract address that will spend tokens
+ * @param {bigint} value - Amount of tokens to approve
+ * @param {number} deadline - Timestamp when the permit expires
+ * @returns {Promise<PaymentRequestMessage>}
+ */
+async function getPermitSignature(signer, tokenAddress, spender, value, deadline) {
+    const erc20PermitContract = new ethers_1.Contract(tokenAddress, ERC20Permit_json_1.default, signer);
+    const nonce = await erc20PermitContract.nonces(await signer.getAddress());
+    const domainData = await erc20PermitContract.eip712Domain();
+    const domain = {
+        version: domainData[2],
+        chainId: domainData[3],
+        verifyingContract: tokenAddress
+    };
+    const types = {
+        Permit: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' }
+        ]
+    };
+    const message = {
+        owner: await signer.getAddress(),
+        spender: spender,
+        value: value,
+        nonce: nonce,
+        deadline: deadline
+    };
+    return signer.signTypedData(domain, types, message);
+}
+exports.getPermitSignature = getPermitSignature;

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./state"), exports);
 __exportStar(require("./onchain-zkp-verifier"), exports);
 __exportStar(require("./onchain-revocation"), exports);
+__exportStar(require("./erc20-permit-sig"), exports);

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,41 @@ 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["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/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}`);
         }

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
@@ -121,6 +122,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,
@@ -168,8 +172,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 +193,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');