@0xpolygonid/js-sdk 1.10.3 → 1.11.0

package/dist/node/cjs/proof/verifiers/pub-signals-verifier.js

@@ -297,10 +297,7 @@ class PubSignalsVerifier {
             }
         };
         this.checkStateExistenceForId = async (userId, userState) => {
-            const { latest } = await this.resolve(userId, userState.bigInt());
-            if (!latest) {
-                throw exports.userStateError;
-            }
+            await this.resolve(userId, userState.bigInt());
         };
         this.checkGlobalState = async (state, id) => {
             return this.rootResolve(state.bigInt(), id.bigInt());
@@ -393,7 +390,9 @@ class PubSignalsVerifier {
             contractState = await this._stateStorage.getStateInfoByIdAndState(idBigInt, state);
         }
         catch (e) {
-            if (e.errorArgs[0] === 'State does not exist') {
+            const stateNotExistErr = (e?.errorArgs ?? [])[0];
+            const errMsg = stateNotExistErr || e.message;
+            if (errMsg === 'State does not exist') {
                 if (isGenesis) {
                     return {
                         latest: true,

package/dist/node/cjs/storage/blockchain/onchain-revocation.js

@@ -7,6 +7,7 @@ exports.OnChainRevocationStorage = void 0;
 const ethers_1 = require("ethers");
 const js_merkletree_1 = require("@iden3/js-merkletree");
 const CredentialStatusResolver_json_1 = __importDefault(require("../blockchain/abi/CredentialStatusResolver.json"));
+const blockchain_1 = require("../../blockchain");
 /**
  * OnChainRevocationStore is a class that allows to interact with the onchain contract
  * and build the revocation status.
@@ -32,6 +33,7 @@ class OnChainRevocationStorage {
             contract = contract.connect(this._signer);
         }
         this._contract = contract;
+        this._transactionService = new blockchain_1.TransactionService(this._provider);
     }
     /**
      * Get revocation status by issuerId, issuerState and nonce from the onchain.
@@ -81,18 +83,8 @@ class OnChainRevocationStorage {
             maxFeePerGas,
             maxPriorityFeePerGas
         };
-        const tx = await this._signer.sendTransaction(request);
-        return tx.wait().then((txReceipt) => {
-            if (!txReceipt) {
-                throw new Error(`transaction: ${tx.hash} failed to mine`);
-            }
-            const status = txReceipt.status;
-            const txnHash = txReceipt.hash;
-            if (!status) {
-                throw new Error(`transaction: ${txnHash} failed to mine`);
-            }
-            return txReceipt;
-        });
+        const { txnReceipt } = await this._transactionService.sendTransactionRequest(this._signer, request);
+        return txnReceipt;
     }
     static convertIssuerInfo(issuer) {
         const [state, claimsTreeRoot, revocationTreeRoot, rootOfRoots] = issuer.map((i) => js_merkletree_1.Hash.fromBigInt(i).hex());

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnChainZKPVerifier = void 0;
 const ethers_1 = require("ethers");
 const ZkpVerifier_json_1 = __importDefault(require("./abi/ZkpVerifier.json"));
+const blockchain_1 = require("../../blockchain");
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
  * and submitZKPResponse.
@@ -79,16 +80,8 @@ class OnChainZKPVerifier {
                 maxFeePerGas,
                 maxPriorityFeePerGas
             };
-            const tx = await ethSigner.sendTransaction(request);
-            const txnReceipt = await tx.wait();
-            if (!txnReceipt) {
-                throw new Error(`transaction: ${tx.hash} failed to mined`);
-            }
-            const status = txnReceipt.status;
-            const txnHash = txnReceipt.hash;
-            if (!status) {
-                throw new Error(`transaction: ${txnHash} failed to mined`);
-            }
+            const transactionService = new blockchain_1.TransactionService(provider);
+            const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
             response.set(txnHash, zkProof);
         }
         return response;

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

@@ -9,6 +9,7 @@ const circuits_1 = require("../../circuits");
 const utils_1 = require("../../utils");
 const State_json_1 = __importDefault(require("./abi/State.json"));
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const blockchain_1 = require("../../blockchain");
 exports.defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -39,6 +40,7 @@ class EthStateStorage {
         const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
         this.provider = new ethers_1.JsonRpcProvider(config.url);
         this.stateContract = new ethers_1.Contract(config.contractAddress, State_json_1.default, this.provider);
+        this._transactionService = new blockchain_1.TransactionService(this.getRpcProvider());
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     async getLatestStateById(id) {
@@ -105,16 +107,39 @@ class EthStateStorage {
             maxFeePerGas,
             maxPriorityFeePerGas
         };
-        const tx = await signer.sendTransaction(request);
-        const txnReceipt = await tx.wait();
-        if (!txnReceipt) {
-            throw new Error(`transaction: ${tx.hash} failed to mined`);
-        }
-        const status = txnReceipt.status;
-        const txnHash = txnReceipt.hash;
-        if (!status) {
-            throw new Error(`transaction: ${txnHash} failed to mined`);
-        }
+        const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
+        return txnHash;
+    }
+    /** {@inheritdoc IStateStorage.publishStateGeneric} */
+    async publishStateGeneric(signer, userStateTransitionInfo) {
+        const { userId, oldUserState, newUserState, isOldStateGenesis, methodId, methodParams } = userStateTransitionInfo;
+        const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
+        const contract = stateContract.connect(signer);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = exports.defaultEthConnectionConfig.maxFeePerGas
+            ? BigInt(exports.defaultEthConnectionConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = exports.defaultEthConnectionConfig.maxPriorityFeePerGas
+            ? BigInt(exports.defaultEthConnectionConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const payload = [
+            userId.bigInt().toString(),
+            oldUserState.bigInt().toString(),
+            newUserState.bigInt().toString(),
+            isOldStateGenesis,
+            methodId,
+            methodParams //'0x'
+        ];
+        const gasLimit = await contract.transitStateGeneric.estimateGas(...payload);
+        const txData = await contract.transitStateGeneric.populateTransaction(...payload);
+        const request = {
+            to: txData.to,
+            data: txData.data,
+            gasLimit,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+        };
+        const { txnHash } = await this._transactionService.sendTransactionRequest(signer, request);
         return txnHash;
     }
     /** {@inheritdoc IStateStorage.getGISTProof} */
@@ -145,6 +170,10 @@ class EthStateStorage {
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
     }
+    /** {@inheritdoc IStateStorage.getRpcProvider} */
+    getRpcProvider() {
+        return this.provider;
+    }
     getStateContractAndProviderForId(id) {
         const idTyped = js_iden3_core_1.Id.fromBigInt(id);
         if (!Array.isArray(this.ethConfig)) {

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

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveDIDDocumentAuth = exports.validateDIDDocumentAuth = exports.buildVerifierId = exports.isGenesisState = void 0;
+exports.buildDIDFromEthPubKey = exports.resolveDIDDocumentAuth = exports.validateDIDDocumentAuth = exports.buildVerifierId = exports.isEthereumIdentity = exports.isGenesisState = void 0;
 const js_crypto_1 = require("@iden3/js-crypto");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_merkletree_1 = require("@iden3/js-merkletree");
+const js_sha3_1 = require("js-sha3");
+const encoding_1 = require("./encoding");
 /**
  * Checks if state is genesis state
  *
- * @param {string} did - did
+ * @param {DID} did - did
  * @param {bigint|string} state  - hash on bigInt or hex string format
  * @returns boolean
  */
@@ -22,6 +24,25 @@ function isGenesisState(did, state) {
     return id.bigInt().toString() === idFromState.bigInt().toString();
 }
 exports.isGenesisState = isGenesisState;
+/**
+ * Checks if DID is an ethereum identity
+ *
+ * @param {DID} did - did
+ * @returns boolean
+ */
+function isEthereumIdentity(did) {
+    const issuerId = js_iden3_core_1.DID.idFromDID(did);
+    try {
+        js_iden3_core_1.Id.ethAddressFromId(issuerId);
+        // is an ethereum identity
+        return true;
+    }
+    catch {
+        // not an ethereum identity (BabyJubJub or other)
+        return false;
+    }
+}
+exports.isEthereumIdentity = isEthereumIdentity;
 const buildVerifierId = (address, info) => {
     address = address.replace('0x', '');
     const ethAddrBytes = js_crypto_1.Hex.decodeString(address);
@@ -53,3 +74,16 @@ const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
     return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
 };
 exports.resolveDIDDocumentAuth = resolveDIDDocumentAuth;
+const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
+    // Use Keccak-256 hash function to get public key hash
+    const hashOfPublicKey = (0, js_sha3_1.keccak256)((0, encoding_1.hexToBytes)(pubKeyEth));
+    // Convert hash to buffer
+    const ethAddressBuffer = (0, encoding_1.hexToBytes)(hashOfPublicKey);
+    // Ethereum Address is '0x' concatenated with last 20 bytes
+    // of the public key hash
+    const ethAddr = ethAddressBuffer.slice(-20);
+    const genesis = (0, js_iden3_core_1.genesisFromEthAddress)(ethAddr);
+    const identifier = new js_iden3_core_1.Id(didType, genesis);
+    return js_iden3_core_1.DID.parseFromId(identifier);
+};
+exports.buildDIDFromEthPubKey = buildDIDFromEthPubKey;

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

@@ -7,7 +7,8 @@ exports.VerifiableConstants = Object.freeze({
         FiELD_IS_EMPTY: 'fieldPath is empty',
         CONTEXT_TYPE_IS_EMPTY: 'ctxType is empty',
         // ErrStateNotFound issuer state is genesis state.
-        IDENTITY_DOES_NOT_EXIST: 'Identity does not exist'
+        IDENTITY_DOES_NOT_EXIST: 'Identity does not exist',
+        NO_AUTH_CRED_FOUND: 'no auth credentials found'
     },
     CREDENTIAL_TYPE: {
         // VerifiableCredential is a W3C verifiable credential type

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

@@ -0,0 +1 @@
+export * from './transaction-service';

package/dist/node/esm/blockchain/transaction-service.js

@@ -0,0 +1,51 @@
+/**
+ * Transaction service to provide interaction with blockchain transactions.
+ * allows to: get tx receipt by tx id, send and resend transaction with new fees.
+ * @class TransactionService
+ * @public
+ * @implements ITransactionService interface
+ */
+export class TransactionService {
+    /**
+     * Creates an instance of TransactionService.
+     * @param {JsonRpcProvider} - RPC provider
+     */
+    constructor(_provider) {
+        this._provider = _provider;
+    }
+    /** {@inheritDoc ITransactionService.getTransactionReceiptAndBlock} */
+    async getTransactionReceiptAndBlock(txnHash) {
+        const receipt = await this._provider.getTransactionReceipt(txnHash);
+        const block = await receipt?.getBlock();
+        return { receipt: receipt || undefined, block };
+    }
+    /** {@inheritDoc ITransactionService.sendTransactionRequest} */
+    async sendTransactionRequest(signer, request) {
+        const tx = await signer.sendTransaction(request);
+        const txnReceipt = await tx.wait();
+        if (!txnReceipt) {
+            throw new Error(`transaction: ${tx.hash} failed to mined`);
+        }
+        const status = txnReceipt.status;
+        const txnHash = txnReceipt.hash;
+        if (!status) {
+            throw new Error(`transaction: ${txnHash} failed to mined`);
+        }
+        return { txnHash, txnReceipt };
+    }
+    /** {@inheritDoc ITransactionService.resendTransaction} */
+    async resendTransaction(signer, request, opts) {
+        const feeData = await this._provider.getFeeData();
+        let { maxFeePerGas, maxPriorityFeePerGas, gasPrice } = feeData;
+        if (opts?.increasedFeesPercentage) {
+            const multiplyVal = BigInt((opts.increasedFeesPercentage + 100) / 100);
+            maxFeePerGas = maxFeePerGas ? maxFeePerGas * multiplyVal : null;
+            maxPriorityFeePerGas = maxPriorityFeePerGas ? maxPriorityFeePerGas * multiplyVal : null;
+            gasPrice = gasPrice ? gasPrice * multiplyVal : null;
+        }
+        request.maxFeePerGas = maxFeePerGas;
+        request.maxPriorityFeePerGas = maxPriorityFeePerGas;
+        request.gasPrice = gasPrice;
+        return this.sendTransactionRequest(signer, request);
+    }
+}

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

@@ -78,7 +78,7 @@ export class CredentialWallet {
             allowedIssuers: [did.string()]
         });
         if (!authBJJCredsOfIssuer.length) {
-            throw new Error('no auth credentials found');
+            throw new Error(VerifiableConstants.ERRORS.NO_AUTH_CRED_FOUND);
         }
         for (let index = 0; index < authBJJCredsOfIssuer.length; index++) {
             const authCred = authBJJCredsOfIssuer[index];

package/dist/node/esm/credentials/status/reverse-sparse-merkle-tree.js

@@ -1,7 +1,7 @@
 import { buildDIDType, BytesHelper, DID, Id } from '@iden3/js-iden3-core';
 import { Hash, Proof, ZERO_HASH, testBit } from '@iden3/js-merkletree';
 import { VerifiableConstants, CredentialStatusType } from '../../verifiable/constants';
-import { isGenesisState } from '../../utils';
+import { isEthereumIdentity, isGenesisState } from '../../utils';
 import { IssuerResolver } from './sparse-merkle-tree';
 /**
  * ProofNode is a partial Reverse Hash Service result
@@ -132,9 +132,13 @@ export class RHSResolver {
                 return this.getRevocationStatusFromIssuerData(issuerDID, issuerData, genesisState);
             }
             const currentStateBigInt = Hash.fromHex(stateHex).bigInt();
-            if (!isGenesisState(issuerDID, currentStateBigInt)) {
+            const isEthIdentity = isEthereumIdentity(issuerDID);
+            if (!isEthIdentity && !isGenesisState(issuerDID, currentStateBigInt)) {
                 throw new Error(`latest state not found and state parameter ${stateHex} is not genesis state`);
             }
+            if (isEthIdentity) {
+                throw new Error(`State must be published for Ethereum based identity`);
+            }
             latestState = currentStateBigInt;
         }
         const rhsHost = credentialStatus.id.split('/node')[0];

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

@@ -6,6 +6,7 @@ import * as uuid from 'uuid';
 import { byteDecoder, byteEncoder } from '../../utils';
 import { processZeroKnowledgeProofRequests } from './common';
 import { CircuitId } from '../../circuits';
+import { AbstractMessageHandler } from './message-handler';
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
@@ -50,7 +51,7 @@ export function createAuthorizationRequestWithMessage(reason, message, sender, c
  * @class AuthHandler
  * @implements implements IAuthHandler interface
  */
-export class AuthHandler {
+export class AuthHandler extends AbstractMessageHandler {
     /**
      * Creates an instance of AuthHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -58,6 +59,7 @@ export class AuthHandler {
      *
      */
     constructor(_packerMgr, _proofService) {
+        super();
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
         this._supportedCircuits = [
@@ -67,6 +69,16 @@ export class AuthHandler {
             CircuitId.LinkedMultiQuery10
         ];
     }
+    handle(message, ctx) {
+        switch (message.type) {
+            case PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE:
+                return this.handleAuthRequest(message, ctx);
+            case PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE:
+                return this.handleAuthResponse(message, ctx);
+            default:
+                return super.handle(message, ctx);
+        }
+    }
     /**
      * @inheritdoc IAuthHandler#parseAuthorizationRequest
      */
@@ -79,44 +91,49 @@ export class AuthHandler {
         authRequest.body.scope = authRequest.body.scope || [];
         return authRequest;
     }
-    /**
-     * @inheritdoc IAuthHandler#handleAuthorizationRequest
-     */
-    async handleAuthorizationRequest(did, request, opts) {
-        const authRequest = await this.parseAuthorizationRequest(request);
+    async handleAuthRequest(authRequest, ctx) {
         if (authRequest.type !== PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE) {
             throw new Error('Invalid message type for authorization request');
         }
-        if (!opts) {
-            opts = {
-                mediaType: MediaType.ZKPMessage
-            };
-        }
-        if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
-            throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
-        }
-        if (authRequest.to) {
-            // override sender did if it's explicitly specified in the auth request
-            did = DID.parse(authRequest.to);
-        }
+        // 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 from = DID.parse(authRequest.from);
-        const responseScope = await processZeroKnowledgeProofRequests(did, authRequest?.body.scope, from, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
-        const authResponse = {
+        const responseScope = await processZeroKnowledgeProofRequests(to, authRequest?.body.scope, from, this._proofService, { mediaType, supportedCircuits: this._supportedCircuits });
+        return {
             id: guid,
-            typ: opts.mediaType,
+            typ: ctx.mediaType,
             type: PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE,
             thid: authRequest.thid ?? guid,
             body: {
                 message: authRequest?.body?.message,
                 scope: responseScope
             },
-            from: did.string(),
+            from: to.string(),
             to: authRequest.from
         };
+    }
+    /**
+     * @inheritdoc IAuthHandler#handleAuthorizationRequest
+     */
+    async handleAuthorizationRequest(did, request, opts) {
+        const authRequest = await this.parseAuthorizationRequest(request);
+        if (!opts) {
+            opts = {
+                mediaType: MediaType.ZKPMessage
+            };
+        }
+        if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+        }
+        const authResponse = await this.handleAuthRequest(authRequest, {
+            senderDid: did,
+            mediaType: opts.mediaType
+        });
         const msgBytes = byteEncoder.encode(JSON.stringify(authResponse));
         const packerOpts = opts.mediaType === MediaType.SignedMessage
             ? opts.packerOptions
@@ -129,10 +146,11 @@ export class AuthHandler {
         }));
         return { authRequest, authResponse, token };
     }
-    /**
-     * @inheritdoc IAuthHandler#handleAuthorizationResponse
-     */
-    async handleAuthorizationResponse(response, request, opts) {
+    async handleAuthResponse(response, ctx) {
+        const request = ctx.request;
+        if (response.type !== PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_RESPONSE_MESSAGE_TYPE) {
+            throw new Error('Invalid message type for authorization response');
+        }
         if ((request.body.message ?? '') !== (response.body.message ?? '')) {
             throw new Error('message for signing from request is not presented in response');
         }
@@ -159,6 +177,12 @@ export class AuthHandler {
             }
             const params = proofRequest.params ?? {};
             params.verifierDid = DID.parse(request.from);
+            const opts = [ctx.acceptedProofGenerationDelay, ctx.acceptedStateTransitionDelay].some((delay) => delay !== undefined)
+                ? {
+                    acceptedProofGenerationDelay: ctx.acceptedProofGenerationDelay,
+                    acceptedStateTransitionDelay: ctx.acceptedStateTransitionDelay
+                }
+                : undefined;
             const { linkID } = await this._proofService.verifyZKPResponse(proofResp, {
                 query: proofRequest.query,
                 sender: response.from,
@@ -181,7 +205,18 @@ export class AuthHandler {
                 throw new Error(`Link id validation failed for group ${groupId}, request linkID to requestIds info: ${JSON.stringify(metas)}`);
             }
         }
-        return { request, response };
+        return response;
+    }
+    /**
+     * @inheritdoc IAuthHandler#handleAuthorizationResponse
+     */
+    async handleAuthorizationResponse(response, request, opts) {
+        const authResp = (await this.handleAuthResponse(response, {
+            request,
+            acceptedStateTransitionDelay: opts?.acceptedStateTransitionDelay,
+            acceptedProofGenerationDelay: opts?.acceptedProofGenerationDelay
+        }));
+        return { request, response: authResp };
     }
     verifyAuthRequest(request) {
         const groupIdValidationMap = {};

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

@@ -34,14 +34,14 @@ const getGroupedQueries = (requestScope) => requestScope.reduce((acc, proofReq)
 /**
  * Processes zero knowledge proof requests.
  *
- * @param senderIdentifier - The identifier of the sender.
+ * @param to - The identifier of the recipient.
  * @param requests - An array of zero knowledge proof requests.
  * @param from - The identifier of the sender.
  * @param proofService - The proof service.
  * @param opts - Additional options for processing the requests.
  * @returns A promise that resolves to an array of zero knowledge proof responses.
  */
-export const processZeroKnowledgeProofRequests = async (senderIdentifier, requests, from, proofService, opts) => {
+export const processZeroKnowledgeProofRequests = async (to, requests, from, proofService, opts) => {
     const requestScope = requests ?? [];
     const combinedQueries = getGroupedQueries(requestScope);
     const groupedCredentialsCache = new Map();
@@ -59,7 +59,7 @@ export const processZeroKnowledgeProofRequests = async (senderIdentifier, reques
             }
             const combinedQuery = combinedQueryData.query;
             if (!groupedCredentialsCache.has(groupId)) {
-                const credWithRevStatus = await proofService.findCredentialByProofQuery(senderIdentifier, combinedQueryData.query);
+                const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
                 if (!credWithRevStatus.cred) {
                     throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
                 }
@@ -67,7 +67,7 @@ export const processZeroKnowledgeProofRequests = async (senderIdentifier, reques
             }
         }
         const credWithRevStatus = groupedCredentialsCache.get(groupId);
-        const zkpRes = await proofService.generateProof(proofReq, senderIdentifier, {
+        const zkpRes = await proofService.generateProof(proofReq, to, {
             verifierDid: from,
             challenge: opts.challenge,
             skipRevocation: Boolean(query.skipClaimRevocationCheck),

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

@@ -2,6 +2,7 @@ import { CircuitId } from '../../circuits/models';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { DID, ChainIds } from '@iden3/js-iden3-core';
 import { processZeroKnowledgeProofRequests } from './common';
+import { AbstractMessageHandler } from './message-handler';
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -11,7 +12,7 @@ import { processZeroKnowledgeProofRequests } from './common';
  * @class ContractRequestHandler
  * @implements implements IContractRequestHandler interface
  */
-export class ContractRequestHandler {
+export class ContractRequestHandler extends AbstractMessageHandler {
     /**
      * Creates an instance of ContractRequestHandler.
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
@@ -20,6 +21,7 @@ export class ContractRequestHandler {
      *
      */
     constructor(_packerMgr, _proofService, _zkpVerifier) {
+        super();
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
         this._zkpVerifier = _zkpVerifier;
@@ -29,6 +31,32 @@ export class ContractRequestHandler {
             CircuitId.AtomicQueryV3OnChain
         ];
     }
+    async handle(message, ctx) {
+        switch (message.type) {
+            case PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE:
+                await this.handleContractInvoke(message, ctx);
+                return null;
+            default:
+                return super.handle(message, ctx);
+        }
+    }
+    async handleContractInvoke(message, ctx) {
+        if (message.type !== PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
+            throw new Error('Invalid message type for contract invoke request');
+        }
+        const { senderDid: did, ethSigner, challenge } = ctx;
+        if (!ctx.ethSigner) {
+            throw new Error("Can't sign transaction. Provide Signer in options.");
+        }
+        const { chain_id } = message.body.transaction_data;
+        const networkFlag = Object.keys(ChainIds).find((key) => ChainIds[key] === chain_id);
+        if (!networkFlag) {
+            throw new Error(`Invalid chain id ${chain_id}`);
+        }
+        const verifierDid = message.from ? DID.parse(message.from) : undefined;
+        const zkpResponses = await processZeroKnowledgeProofRequests(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+        return this._zkpVerifier.submitZKPResponse(ethSigner, message.body.transaction_data, zkpResponses);
+    }
     /**
      * unpacks contract-invoke request
      * @beta
@@ -54,19 +82,10 @@ export class ContractRequestHandler {
      */
     async handleContractInvokeRequest(did, request, opts) {
         const ciRequest = await this.parseContractInvokeRequest(request);
-        if (ciRequest.type !== PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
-            throw new Error('Invalid message type for contract invoke request');
-        }
-        if (!opts.ethSigner) {
-            throw new Error("Can't sign transaction. Provide Signer in options.");
-        }
-        const { chain_id } = ciRequest.body.transaction_data;
-        const networkFlag = Object.keys(ChainIds).find((key) => ChainIds[key] === chain_id);
-        if (!networkFlag) {
-            throw new Error(`Invalid chain id ${chain_id}`);
-        }
-        const verifierDid = ciRequest.from ? DID.parse(ciRequest.from) : undefined;
-        const zkpResponses = await processZeroKnowledgeProofRequests(did, ciRequest?.body?.scope, verifierDid, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
-        return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkpResponses);
+        return this.handleContractInvoke(ciRequest, {
+            senderDid: did,
+            ethSigner: opts.ethSigner,
+            challenge: opts.challenge
+        });
     }
 }