@0xpolygonid/js-sdk 1.28.1 → 1.29.1

package/dist/browser/esm/index.js

@@ -52547,6 +52547,395 @@ class TransactionService {
     }
 }
 
+/**
+ * creates empty basic message
+ *
+ * @returns BasicMessage
+ */
+const basicMessageFactory = () => {
+    return {
+        id: '',
+        typ: '',
+        thid: '',
+        type: '',
+        body: {},
+        from: '',
+        to: ''
+    };
+};
+/**
+ * create empty header stub
+ *
+ * @returns {HeaderStub}
+ */
+const headerStubFactory = () => {
+    return {
+        typ: ''
+    };
+};
+
+// Envelope Errors
+// Token Errors
+const ErrUnknownCircuitID = "unknown circuit ID. can't verify msg sender";
+const ErrSenderNotUsedTokenCreation = 'sender of message is not used for jwz token creation';
+// ZKP-Packer Errors
+const ErrPackedWithUnsupportedCircuit = 'message was packed with unsupported circuit';
+const ErrProofIsInvalid = 'message proof is invalid';
+const ErrStateVerificationFailed = 'message state verification failed';
+const ErrNoProvingMethodAlg = 'unknown proving method algorithm';
+
+const objectIs = (obj, //eslint-disable-line @typescript-eslint/no-explicit-any
+targetObj //eslint-disable-line @typescript-eslint/no-explicit-any
+) => {
+    Object.keys(targetObj).forEach((prop) => {
+        if (!obj[prop]) {
+            return false;
+        }
+        if (typeof targetObj[prop] !== typeof obj[prop]) {
+            return false;
+        }
+    });
+    return true;
+};
+//eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isProtocolMessage = (message) => {
+    const basicMessage = basicMessageFactory();
+    Object.keys(basicMessage).forEach((prop) => {
+        if (!message[prop]) {
+            return false;
+        }
+        if (prop !== 'body') {
+            const res = typeof basicMessage[prop] ===
+                typeof message[prop]; //eslint-disable-line @typescript-eslint/no-explicit-any
+            if (!res) {
+                return false;
+            }
+        }
+    });
+    return true;
+};
+/**
+ * helper function to convert serialized JSON bytes to protocol message
+ *
+ * @param {Uint8Array} bytes
+ * @returns  {BasicMessage}
+ */
+const bytesToProtocolMessage = (bytes) => {
+    const str = byteDecoder.decode(bytes);
+    const message = JSON.parse(str);
+    if (!isProtocolMessage(message)) ;
+    return message;
+};
+/**
+ * helper function to convert serialized JSON bytes to header stub
+ * so we can work with know the media type of the message
+ *
+ * @param {Uint8Array} envelope
+ * @returns {HeaderStub}
+ */
+const bytesToHeaderStub = (envelope) => {
+    const tmpObj = headerStubFactory();
+    const str = byteDecoder.decode(envelope);
+    const message = JSON.parse(str);
+    if (!objectIs(message, tmpObj)) ;
+    return message;
+};
+
+const IDEN3_PROTOCOL = 'https://iden3-communication.io/';
+const DIDCOMM_PROTOCOL = 'https://didcomm.org/';
+/**
+ * Constants for Iden3 protocol
+ */
+const PROTOCOL_MESSAGE_TYPE = Object.freeze({
+    // AuthorizationV2RequestMessageType defines auth request type of the communication protocol
+    AUTHORIZATION_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}authorization/1.0/request`,
+    // AuthorizationResponseMessageType defines auth response type of the communication protocol
+    AUTHORIZATION_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}authorization/1.0/response`,
+    // CredentialIssuanceRequestMessageType accepts request for credential creation
+    CREDENTIAL_ISSUANCE_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/issuance-request`,
+    // CredentialFetchRequestMessageType is type for request of credential generation
+    CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/fetch-request`,
+    // CredentialOfferMessageType is type of message with credential offering
+    CREDENTIAL_OFFER_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/offer`,
+    // CredentialIssuanceResponseMessageType is type for message with a credential issuance
+    CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/issuance-response`,
+    // CredentialRefreshMessageType is type for message with a credential issuance
+    CREDENTIAL_REFRESH_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/refresh`,
+    // DeviceRegistrationRequestMessageType defines device registration request type of the communication protocol
+    DEVICE_REGISTRATION_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}devices/1.0/registration`,
+    // MessageFetMessageFetchRequestMessageType defines message fetch request type of the communication protocol.
+    MESSAGE_FETCH_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}messages/1.0/fetch`,
+    // ProofGenerationRequestMessageType is type for request of proof generation
+    PROOF_GENERATION_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/request`,
+    // ProofGenerationResponseMessageType is type for response of proof generation
+    PROOF_GENERATION_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/response`,
+    // RevocationStatusRequestMessageType is type for request of revocation status
+    REVOCATION_STATUS_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}revocation/1.0/request-status`,
+    // RevocationStatusResponseMessageType is type for response with a revocation status
+    REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}revocation/1.0/status`,
+    // ContractInvokeRequestMessageType is type for request of contract invoke request
+    CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-request`,
+    // ContractInvokeResponseMessageType is type for response of contract invoke request
+    CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-response`,
+    // CredentialOnchainOfferMessageType is type of message with credential onchain offering
+    CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/onchain-offer`,
+    // ProposalRequestMessageType is type for proposal-request message
+    PROPOSAL_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/proposal-request`,
+    // ProposalMessageType is type for proposal message
+    PROPOSAL_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/proposal`,
+    // PaymentRequestMessageType is type for payment-request message
+    PAYMENT_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment-request`,
+    // PaymentMessageType is type for payment message
+    PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`,
+    // DiscoveryProtocolQueriesMessageType is type for didcomm discovery protocol queries
+    DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/queries`,
+    // DiscoveryProtocolDiscloseMessageType is type for didcomm discovery protocol disclose
+    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`,
+    // ProblemReportMessageType is type for didcomm problem report
+    PROBLEM_REPORT_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}report-problem/2.0/problem-report`
+});
+/**
+ * Media types for iden3 comm communication protocol
+ *
+ * @enum {number}
+ */
+var MediaType;
+(function (MediaType) {
+    MediaType["ZKPMessage"] = "application/iden3-zkp-json";
+    MediaType["PlainMessage"] = "application/iden3comm-plain-json";
+    MediaType["SignedMessage"] = "application/iden3comm-signed-json";
+})(MediaType || (MediaType = {}));
+const SUPPORTED_PUBLIC_KEY_TYPES = {
+    ES256K: [
+        'EcdsaSecp256k1VerificationKey2019',
+        /**
+         * Equivalent to EcdsaSecp256k1VerificationKey2019 when key is an ethereumAddress
+         */
+        'EcdsaSecp256k1RecoveryMethod2020',
+        'JsonWebKey2020'
+    ],
+    'ES256K-R': [
+        'EcdsaSecp256k1VerificationKey2019',
+        /**
+         * Equivalent to EcdsaSecp256k1VerificationKey2019 when key is an ethereumAddress
+         */
+        'EcdsaSecp256k1RecoveryMethod2020',
+        'JsonWebKey2020'
+    ]
+};
+var ProtocolVersion;
+(function (ProtocolVersion) {
+    ProtocolVersion["V1"] = "iden3comm/v1";
+})(ProtocolVersion || (ProtocolVersion = {}));
+var AcceptAuthCircuits;
+(function (AcceptAuthCircuits) {
+    AcceptAuthCircuits["AuthV2"] = "authV2";
+    AcceptAuthCircuits["AuthV3"] = "authV3";
+})(AcceptAuthCircuits || (AcceptAuthCircuits = {}));
+var AcceptJwzAlgorithms;
+(function (AcceptJwzAlgorithms) {
+    AcceptJwzAlgorithms["Groth16"] = "groth16";
+})(AcceptJwzAlgorithms || (AcceptJwzAlgorithms = {}));
+var AcceptJwsAlgorithms;
+(function (AcceptJwsAlgorithms) {
+    AcceptJwsAlgorithms["ES256K"] = "ES256K";
+    AcceptJwsAlgorithms["ES256KR"] = "ES256K-R";
+})(AcceptJwsAlgorithms || (AcceptJwsAlgorithms = {}));
+const defaultAcceptProfile = {
+    protocolVersion: ProtocolVersion.V1,
+    env: MediaType.ZKPMessage,
+    circuits: [AcceptAuthCircuits.AuthV2],
+    alg: [AcceptJwzAlgorithms.Groth16]
+};
+const DEFAULT_PROOF_VERIFY_DELAY = 1 * 60 * 60 * 1000; // 1 hour
+const DEFAULT_AUTH_VERIFY_DELAY = 5 * 60 * 1000; // 5 minutes
+
+var constants = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get AcceptAuthCircuits () { return AcceptAuthCircuits; },
+    get AcceptJwsAlgorithms () { return AcceptJwsAlgorithms; },
+    get AcceptJwzAlgorithms () { return AcceptJwzAlgorithms; },
+    DEFAULT_AUTH_VERIFY_DELAY: DEFAULT_AUTH_VERIFY_DELAY,
+    DEFAULT_PROOF_VERIFY_DELAY: DEFAULT_PROOF_VERIFY_DELAY,
+    get MediaType () { return MediaType; },
+    PROTOCOL_MESSAGE_TYPE: PROTOCOL_MESSAGE_TYPE,
+    get ProtocolVersion () { return ProtocolVersion; },
+    SUPPORTED_PUBLIC_KEY_TYPES: SUPPORTED_PUBLIC_KEY_TYPES,
+    defaultAcceptProfile: defaultAcceptProfile
+});
+
+const DIDAuthenticationSection = 'authentication';
+const resolveVerificationMethods = (didDocument) => {
+    const vms = didDocument.verificationMethod || [];
+    // prioritize: first verification methods to be chosen are from `authentication` section.
+    const sortedVerificationMethods = (didDocument[DIDAuthenticationSection] || [])
+        .map((verificationMethod) => {
+        if (typeof verificationMethod === 'string') {
+            return vms.find((i) => i.id === verificationMethod);
+        }
+        return verificationMethod;
+    })
+        .filter((key) => key);
+    // add all other verification methods
+    for (let index = 0; index < vms.length; index++) {
+        const id = vms[index].id;
+        if (sortedVerificationMethods.findIndex((vm) => vm.id === id) === -1) {
+            sortedVerificationMethods.push(vms[index]);
+        }
+    }
+    return sortedVerificationMethods;
+};
+const extractPublicKeyBytes = (vm) => {
+    const isSupportedVmType = Object.keys(SUPPORTED_PUBLIC_KEY_TYPES).some((key) => SUPPORTED_PUBLIC_KEY_TYPES[key].includes(vm.type));
+    if (vm.publicKeyBase58 && isSupportedVmType) {
+        return { publicKeyBytes: base58ToBytes$1(vm.publicKeyBase58), kmsKeyType: KmsKeyType.Secp256k1 };
+    }
+    if (vm.publicKeyBase64 && isSupportedVmType) {
+        return {
+            publicKeyBytes: base64UrlToBytes(vm.publicKeyBase64),
+            kmsKeyType: KmsKeyType.Secp256k1
+        };
+    }
+    if (vm.publicKeyHex && isSupportedVmType) {
+        return { publicKeyBytes: hexToBytes$3(vm.publicKeyHex), kmsKeyType: KmsKeyType.Secp256k1 };
+    }
+    if (vm.publicKeyJwk &&
+        vm.publicKeyJwk.crv === 'secp256k1' &&
+        vm.publicKeyJwk.x &&
+        vm.publicKeyJwk.y) {
+        const [xHex, yHex] = [
+            base64UrlToBytes(vm.publicKeyJwk.x),
+            base64UrlToBytes(vm.publicKeyJwk.y)
+        ].map(bytesToHex$3);
+        const x = xHex.includes('0x') ? BigInt(xHex) : BigInt(`0x${xHex}`);
+        const y = yHex.includes('0x') ? BigInt(yHex) : BigInt(`0x${yHex}`);
+        return {
+            publicKeyBytes: secp256k1$1.ProjectivePoint.fromAffine({
+                x,
+                y
+            }).toRawBytes(false),
+            kmsKeyType: KmsKeyType.Secp256k1
+        };
+    }
+    return { publicKeyBytes: null };
+};
+
+const packZkpProof = (inputs, a, b, c) => {
+    return new AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+};
+const prepareZkpProof = (proof) => {
+    return {
+        a: proof.pi_a.slice(0, 2),
+        b: [
+            [proof.pi_b[0][1], proof.pi_b[0][0]],
+            [proof.pi_b[1][1], proof.pi_b[1][0]]
+        ],
+        c: proof.pi_c.slice(0, 2)
+    };
+};
+
+function isProtocolVersion(value) {
+    return Object.values(ProtocolVersion).includes(value);
+}
+function isMediaType(value) {
+    return Object.values(MediaType).includes(value);
+}
+function isAcceptAuthCircuits(value) {
+    return Object.values(AcceptAuthCircuits).includes(value);
+}
+function isAcceptJwsAlgorithms(value) {
+    return Object.values(AcceptJwsAlgorithms).includes(value);
+}
+function isAcceptJwzAlgorithms(value) {
+    return Object.values(AcceptJwzAlgorithms).includes(value);
+}
+const buildAccept = (profiles) => {
+    const result = [];
+    for (const profile of profiles) {
+        let accept = `${profile.protocolVersion};env=${profile.env}`;
+        if (profile.circuits?.length) {
+            accept += `;circuitId=${profile.circuits.join(',')}`;
+        }
+        if (profile.alg?.length) {
+            accept += `;alg=${profile.alg.join(',')}`;
+        }
+        result.push(accept);
+    }
+    return result;
+};
+const parseAcceptProfile = (profile) => {
+    const params = profile.split(';');
+    if (params.length < 2) {
+        throw new Error('Invalid accept profile');
+    }
+    const protocolVersion = params[0].trim();
+    if (!isProtocolVersion(protocolVersion)) {
+        throw new Error(`Protocol version '${protocolVersion}' not supported`);
+    }
+    const envParam = params[1].split('=');
+    if (envParam.length !== 2) {
+        throw new Error(`Invalid accept profile 'env' parameter`);
+    }
+    const env = params[1].split('=')[1].trim();
+    if (!isMediaType(env)) {
+        throw new Error(`Envelop '${env}' not supported`);
+    }
+    const circuitsIndex = params.findIndex((i) => i.includes('circuitId='));
+    if (env !== MediaType.ZKPMessage && circuitsIndex > 0) {
+        throw new Error(`Circuits not supported for env '${env}'`);
+    }
+    let circuits = undefined;
+    if (circuitsIndex > 0) {
+        circuits = params[circuitsIndex]
+            .split('=')[1]
+            .split(',')
+            .map((i) => i.trim())
+            .map((i) => {
+            if (!isAcceptAuthCircuits(i)) {
+                throw new Error(`Circuit '${i}' not supported`);
+            }
+            return i;
+        });
+    }
+    const algIndex = params.findIndex((i) => i.includes('alg='));
+    let alg = undefined;
+    if (algIndex > 0) {
+        if (env === MediaType.ZKPMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwzAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else if (env === MediaType.SignedMessage) {
+            alg = params[algIndex]
+                .split('=')[1]
+                .split(',')
+                .map((i) => {
+                i = i.trim();
+                if (!isAcceptJwsAlgorithms(i)) {
+                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
+                }
+                return i;
+            });
+        }
+        else {
+            throw new Error(`Algorithm not supported for '${env}'`);
+        }
+    }
+    return {
+        protocolVersion,
+        env,
+        circuits,
+        alg
+    };
+};
+
 const defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -52616,17 +53005,15 @@ class EthStateStorage {
         const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
         const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
         const contract = stateContract.connect(signer);
+        const preparedZkpProof = prepareZkpProof(proof.proof);
         const payload = [
             userId.bigInt().toString(),
             oldUserState.bigInt().toString(),
             newUserState.bigInt().toString(),
             isOldStateGenesis,
-            proof.proof.pi_a.slice(0, 2),
-            [
-                [proof.proof.pi_b[0][1], proof.proof.pi_b[0][0]],
-                [proof.proof.pi_b[1][1], proof.proof.pi_b[1][0]]
-            ],
-            proof.proof.pi_c.slice(0, 2)
+            preparedZkpProof.a,
+            preparedZkpProof.b,
+            preparedZkpProof.c
         ];
         const feeData = await provider.getFeeData();
         const maxFeePerGas = defaultEthConnectionConfig.maxFeePerGas
@@ -52733,184 +53120,524 @@ var abi$2 = [
 	{
 		inputs: [
 		],
-		name: "InvalidInitialization",
-		type: "error"
+		name: "InvalidInitialization",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "string",
+				name: "message",
+				type: "string"
+			},
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				internalType: "uint256",
+				name: "linkID",
+				type: "uint256"
+			},
+			{
+				internalType: "uint64",
+				name: "requestIdToCompare",
+				type: "uint64"
+			},
+			{
+				internalType: "uint256",
+				name: "linkIdToCompare",
+				type: "uint256"
+			}
+		],
+		name: "LinkedProofError",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NotInitializing",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "OwnableInvalidOwner",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "OwnableUnauthorizedAccount",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "uint64",
+				name: "version",
+				type: "uint64"
+			}
+		],
+		name: "Initialized",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "OwnershipTransferStarted",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "OwnershipTransferred",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "requestOwner",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "metadata",
+				type: "string"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "validator",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "ZKPRequestSet",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "caller",
+				type: "address"
+			}
+		],
+		name: "ZKPResponseSubmitted",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "REQUESTS_RETURN_LIMIT",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "VERSION",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "acceptOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract ICircuitValidator",
+				name: "validator",
+				type: "address"
+			}
+		],
+		name: "addValidatorToWhitelist",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "disableZKPRequest",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "enableZKPRequest",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
 		inputs: [
 			{
-				internalType: "string",
-				name: "message",
-				type: "string"
+				internalType: "address",
+				name: "sender",
+				type: "address"
 			},
 			{
 				internalType: "uint64",
 				name: "requestId",
 				type: "uint64"
-			},
+			}
+		],
+		name: "getProofStatus",
+		outputs: [
 			{
-				internalType: "uint256",
-				name: "linkID",
-				type: "uint256"
+				components: [
+					{
+						internalType: "bool",
+						name: "isVerified",
+						type: "bool"
+					},
+					{
+						internalType: "string",
+						name: "validatorVersion",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "blockNumber",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "blockTimestamp",
+						type: "uint256"
+					}
+				],
+				internalType: "struct IZKPVerifier.ProofStatus",
+				name: "",
+				type: "tuple"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "user",
+				type: "address"
 			},
 			{
 				internalType: "uint64",
-				name: "requestIdToCompare",
+				name: "requestId",
 				type: "uint64"
 			},
+			{
+				internalType: "string",
+				name: "key",
+				type: "string"
+			}
+		],
+		name: "getProofStorageField",
+		outputs: [
 			{
 				internalType: "uint256",
-				name: "linkIdToCompare",
+				name: "",
 				type: "uint256"
 			}
 		],
-		name: "LinkedProofError",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "NotInitializing",
-		type: "error"
+		stateMutability: "view",
+		type: "function"
 	},
 	{
 		inputs: [
 			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
 			}
 		],
-		name: "OwnableInvalidOwner",
-		type: "error"
-	},
-	{
-		inputs: [
+		name: "getRequestOwner",
+		outputs: [
 			{
 				internalType: "address",
-				name: "account",
+				name: "",
 				type: "address"
 			}
 		],
-		name: "OwnableUnauthorizedAccount",
-		type: "error"
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		anonymous: false,
 		inputs: [
 			{
-				indexed: false,
 				internalType: "uint64",
-				name: "version",
+				name: "requestId",
 				type: "uint64"
 			}
 		],
-		name: "Initialized",
-		type: "event"
+		name: "getZKPRequest",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "metadata",
+						type: "string"
+					},
+					{
+						internalType: "contract ICircuitValidator",
+						name: "validator",
+						type: "address"
+					},
+					{
+						internalType: "bytes",
+						name: "data",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IZKPVerifier.ZKPRequest",
+				name: "zkpRequest",
+				type: "tuple"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		anonymous: false,
 		inputs: [
 			{
-				indexed: true,
-				internalType: "address",
-				name: "previousOwner",
-				type: "address"
+				internalType: "uint256",
+				name: "startIndex",
+				type: "uint256"
 			},
 			{
-				indexed: true,
-				internalType: "address",
-				name: "newOwner",
-				type: "address"
+				internalType: "uint256",
+				name: "length",
+				type: "uint256"
 			}
 		],
-		name: "OwnershipTransferStarted",
-		type: "event"
+		name: "getZKPRequests",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "metadata",
+						type: "string"
+					},
+					{
+						internalType: "contract ICircuitValidator",
+						name: "validator",
+						type: "address"
+					},
+					{
+						internalType: "bytes",
+						name: "data",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IZKPVerifier.ZKPRequest[]",
+				name: "",
+				type: "tuple[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		anonymous: false,
 		inputs: [
+		],
+		name: "getZKPRequestsCount",
+		outputs: [
 			{
-				indexed: true,
-				internalType: "address",
-				name: "previousOwner",
-				type: "address"
-			},
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
-				indexed: true,
-				internalType: "address",
-				name: "newOwner",
+				internalType: "contract IStateCrossChain",
+				name: "stateCrossChain",
 				type: "address"
 			}
 		],
-		name: "OwnershipTransferred",
-		type: "event"
+		name: "initialize",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		anonymous: false,
 		inputs: [
 			{
-				indexed: true,
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
-			},
-			{
-				indexed: true,
 				internalType: "address",
-				name: "requestOwner",
+				name: "sender",
 				type: "address"
 			},
 			{
-				indexed: false,
-				internalType: "string",
-				name: "metadata",
-				type: "string"
-			},
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
+			}
+		],
+		name: "isProofVerified",
+		outputs: [
 			{
-				indexed: false,
-				internalType: "address",
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract ICircuitValidator",
 				name: "validator",
 				type: "address"
-			},
+			}
+		],
+		name: "isWhitelistedValidator",
+		outputs: [
 			{
-				indexed: false,
-				internalType: "bytes",
-				name: "data",
-				type: "bytes"
+				internalType: "bool",
+				name: "",
+				type: "bool"
 			}
 		],
-		name: "ZKPRequestSet",
-		type: "event"
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		anonymous: false,
 		inputs: [
 			{
-				indexed: true,
 				internalType: "uint64",
 				name: "requestId",
 				type: "uint64"
-			},
+			}
+		],
+		name: "isZKPRequestEnabled",
+		outputs: [
 			{
-				indexed: true,
-				internalType: "address",
-				name: "caller",
-				type: "address"
+				internalType: "bool",
+				name: "",
+				type: "bool"
 			}
 		],
-		name: "ZKPResponseSubmitted",
-		type: "event"
+		stateMutability: "view",
+		type: "function"
 	},
 	{
 		inputs: [
 		],
-		name: "REQUESTS_RETURN_LIMIT",
+		name: "owner",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "address",
 				name: "",
-				type: "uint256"
+				type: "address"
 			}
 		],
 		stateMutability: "view",
@@ -52919,12 +53646,12 @@ var abi$2 = [
 	{
 		inputs: [
 		],
-		name: "VERSION",
+		name: "pendingOwner",
 		outputs: [
 			{
-				internalType: "string",
+				internalType: "address",
 				name: "",
-				type: "string"
+				type: "address"
 			}
 		],
 		stateMutability: "view",
@@ -52932,8 +53659,13 @@ var abi$2 = [
 	},
 	{
 		inputs: [
+			{
+				internalType: "contract ICircuitValidator",
+				name: "validator",
+				type: "address"
+			}
 		],
-		name: "acceptOwnership",
+		name: "removeValidatorFromWhitelist",
 		outputs: [
 		],
 		stateMutability: "nonpayable",
@@ -52941,13 +53673,8 @@ var abi$2 = [
 	},
 	{
 		inputs: [
-			{
-				internalType: "contract ICircuitValidator",
-				name: "validator",
-				type: "address"
-			}
 		],
-		name: "addValidatorToWhitelist",
+		name: "renounceOwnership",
 		outputs: [
 		],
 		stateMutability: "nonpayable",
@@ -52961,10 +53688,15 @@ var abi$2 = [
 				type: "uint64"
 			}
 		],
-		name: "disableZKPRequest",
+		name: "requestIdExists",
 		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
 		],
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
@@ -52973,9 +53705,14 @@ var abi$2 = [
 				internalType: "uint64",
 				name: "requestId",
 				type: "uint64"
+			},
+			{
+				internalType: "address",
+				name: "requestOwner",
+				type: "address"
 			}
 		],
-		name: "enableZKPRequest",
+		name: "setRequestOwner",
 		outputs: [
 		],
 		stateMutability: "nonpayable",
@@ -52984,92 +53721,234 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "address",
-				name: "sender",
-				type: "address"
+				internalType: "uint64",
+				name: "requestId",
+				type: "uint64"
 			},
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "metadata",
+						type: "string"
+					},
+					{
+						internalType: "contract ICircuitValidator",
+						name: "validator",
+						type: "address"
+					},
+					{
+						internalType: "bytes",
+						name: "data",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IZKPVerifier.ZKPRequest",
+				name: "request",
+				type: "tuple"
+			}
+		],
+		name: "setZKPRequest",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
 				internalType: "uint64",
 				name: "requestId",
 				type: "uint64"
+			},
+			{
+				internalType: "uint256[]",
+				name: "inputs",
+				type: "uint256[]"
+			},
+			{
+				internalType: "uint256[2]",
+				name: "a",
+				type: "uint256[2]"
+			},
+			{
+				internalType: "uint256[2][2]",
+				name: "b",
+				type: "uint256[2][2]"
+			},
+			{
+				internalType: "uint256[2]",
+				name: "c",
+				type: "uint256[2]"
 			}
 		],
-		name: "getProofStatus",
+		name: "submitZKPResponse",
 		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
 				components: [
 					{
-						internalType: "bool",
-						name: "isVerified",
-						type: "bool"
-					},
-					{
-						internalType: "string",
-						name: "validatorVersion",
-						type: "string"
+						internalType: "uint64",
+						name: "requestId",
+						type: "uint64"
 					},
 					{
-						internalType: "uint256",
-						name: "blockNumber",
-						type: "uint256"
+						internalType: "bytes",
+						name: "zkProof",
+						type: "bytes"
 					},
 					{
-						internalType: "uint256",
-						name: "blockTimestamp",
-						type: "uint256"
+						internalType: "bytes",
+						name: "data",
+						type: "bytes"
 					}
 				],
-				internalType: "struct IZKPVerifier.ProofStatus",
-				name: "",
-				type: "tuple"
+				internalType: "struct ZKPResponse[]",
+				name: "responses",
+				type: "tuple[]"
+			},
+			{
+				internalType: "bytes",
+				name: "crossChainProof",
+				type: "bytes"
 			}
 		],
-		stateMutability: "view",
+		name: "submitZKPResponseV2",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
 		inputs: [
 			{
 				internalType: "address",
-				name: "user",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "transferOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
 				type: "address"
 			},
+			{
+				internalType: "uint64[]",
+				name: "requestIds",
+				type: "uint64[]"
+			}
+		],
+		name: "verifyLinkedProofs",
+		outputs: [
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
 				internalType: "uint64",
 				name: "requestId",
 				type: "uint64"
 			},
 			{
-				internalType: "string",
-				name: "key",
-				type: "string"
+				internalType: "uint256[]",
+				name: "inputs",
+				type: "uint256[]"
+			},
+			{
+				internalType: "uint256[2]",
+				name: "a",
+				type: "uint256[2]"
+			},
+			{
+				internalType: "uint256[2][2]",
+				name: "b",
+				type: "uint256[2][2]"
+			},
+			{
+				internalType: "uint256[2]",
+				name: "c",
+				type: "uint256[2]"
+			},
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "verifyZKPResponse",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "key",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "inputValue",
+						type: "uint256"
+					}
+				],
+				internalType: "struct ICircuitValidator.KeyToInputValue[]",
+				name: "",
+				type: "tuple[]"
 			}
 		],
-		name: "getProofStorageField",
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "version",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "string",
 				name: "",
-				type: "uint256"
+				type: "string"
 			}
 		],
-		stateMutability: "view",
+		stateMutability: "pure",
 		type: "function"
-	},
+	}
+];
+
+var IVerifierABI = [
 	{
 		inputs: [
 			{
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
+				internalType: "uint256",
+				name: "multiRequestId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "userAddress",
+				type: "address"
 			}
 		],
-		name: "getRequestOwner",
+		name: "areMultiRequestProofsVerified",
 		outputs: [
 			{
-				internalType: "address",
+				internalType: "bool",
 				name: "",
-				type: "address"
+				type: "bool"
 			}
 		],
 		stateMutability: "view",
@@ -53078,34 +53957,44 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
+				internalType: "uint256",
+				name: "groupID",
+				type: "uint256"
 			}
 		],
-		name: "getZKPRequest",
+		name: "getGroupedRequests",
 		outputs: [
 			{
 				components: [
+					{
+						internalType: "uint256",
+						name: "requestId",
+						type: "uint256"
+					},
 					{
 						internalType: "string",
 						name: "metadata",
 						type: "string"
 					},
 					{
-						internalType: "contract ICircuitValidator",
+						internalType: "contract IRequestValidator",
 						name: "validator",
 						type: "address"
 					},
 					{
 						internalType: "bytes",
-						name: "data",
+						name: "params",
 						type: "bytes"
+					},
+					{
+						internalType: "address",
+						name: "creator",
+						type: "address"
 					}
 				],
-				internalType: "struct IZKPVerifier.ZKPRequest",
-				name: "zkpRequest",
-				type: "tuple"
+				internalType: "struct IVerifier.RequestInfo[]",
+				name: "",
+				type: "tuple[]"
 			}
 		],
 		stateMutability: "view",
@@ -53113,40 +54002,54 @@ var abi$2 = [
 	},
 	{
 		inputs: [
+		],
+		name: "getGroupsCount",
+		outputs: [
 			{
 				internalType: "uint256",
-				name: "startIndex",
+				name: "",
 				type: "uint256"
-			},
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
 				internalType: "uint256",
-				name: "length",
+				name: "multiRequestId",
 				type: "uint256"
 			}
 		],
-		name: "getZKPRequests",
+		name: "getMultiRequest",
 		outputs: [
 			{
 				components: [
 					{
-						internalType: "string",
-						name: "metadata",
-						type: "string"
+						internalType: "uint256",
+						name: "multiRequestId",
+						type: "uint256"
 					},
 					{
-						internalType: "contract ICircuitValidator",
-						name: "validator",
-						type: "address"
+						internalType: "uint256[]",
+						name: "requestIds",
+						type: "uint256[]"
+					},
+					{
+						internalType: "uint256[]",
+						name: "groupIds",
+						type: "uint256[]"
 					},
 					{
 						internalType: "bytes",
-						name: "data",
+						name: "metadata",
 						type: "bytes"
 					}
 				],
-				internalType: "struct IZKPVerifier.ZKPRequest[]",
-				name: "",
-				type: "tuple[]"
+				internalType: "struct IVerifier.MultiRequest",
+				name: "multiRequest",
+				type: "tuple"
 			}
 		],
 		stateMutability: "view",
@@ -53154,13 +54057,45 @@ var abi$2 = [
 	},
 	{
 		inputs: [
+			{
+				internalType: "uint256",
+				name: "multiRequestId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "userAddress",
+				type: "address"
+			}
 		],
-		name: "getZKPRequestsCount",
+		name: "getMultiRequestProofsStatus",
 		outputs: [
 			{
-				internalType: "uint256",
+				components: [
+					{
+						internalType: "uint256",
+						name: "requestId",
+						type: "uint256"
+					},
+					{
+						internalType: "bool",
+						name: "isVerified",
+						type: "bool"
+					},
+					{
+						internalType: "string",
+						name: "validatorVersion",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "timestamp",
+						type: "uint256"
+					}
+				],
+				internalType: "struct IVerifier.RequestProofStatus[]",
 				name: "",
-				type: "uint256"
+				type: "tuple[]"
 			}
 		],
 		stateMutability: "view",
@@ -53169,15 +54104,47 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "contract IStateCrossChain",
-				name: "stateCrossChain",
-				type: "address"
+				internalType: "uint256",
+				name: "requestId",
+				type: "uint256"
 			}
 		],
-		name: "initialize",
+		name: "getRequest",
 		outputs: [
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "requestId",
+						type: "uint256"
+					},
+					{
+						internalType: "string",
+						name: "metadata",
+						type: "string"
+					},
+					{
+						internalType: "contract IRequestValidator",
+						name: "validator",
+						type: "address"
+					},
+					{
+						internalType: "bytes",
+						name: "params",
+						type: "bytes"
+					},
+					{
+						internalType: "address",
+						name: "creator",
+						type: "address"
+					}
+				],
+				internalType: "struct IVerifier.RequestInfo",
+				name: "request",
+				type: "tuple"
+			}
 		],
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
@@ -53188,17 +54155,39 @@ var abi$2 = [
 				type: "address"
 			},
 			{
-				internalType: "uint64",
+				internalType: "uint256",
 				name: "requestId",
-				type: "uint64"
+				type: "uint256"
 			}
 		],
-		name: "isProofVerified",
+		name: "getRequestProofStatus",
 		outputs: [
 			{
-				internalType: "bool",
+				components: [
+					{
+						internalType: "uint256",
+						name: "requestId",
+						type: "uint256"
+					},
+					{
+						internalType: "bool",
+						name: "isVerified",
+						type: "bool"
+					},
+					{
+						internalType: "string",
+						name: "validatorVersion",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "timestamp",
+						type: "uint256"
+					}
+				],
+				internalType: "struct IVerifier.RequestProofStatus",
 				name: "",
-				type: "bool"
+				type: "tuple"
 			}
 		],
 		stateMutability: "view",
@@ -53206,18 +54195,13 @@ var abi$2 = [
 	},
 	{
 		inputs: [
-			{
-				internalType: "contract ICircuitValidator",
-				name: "validator",
-				type: "address"
-			}
 		],
-		name: "isWhitelistedValidator",
+		name: "getRequestsCount",
 		outputs: [
 			{
-				internalType: "bool",
+				internalType: "uint256",
 				name: "",
-				type: "bool"
+				type: "uint256"
 			}
 		],
 		stateMutability: "view",
@@ -53226,17 +54210,27 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "uint64",
+				internalType: "uint256",
 				name: "requestId",
-				type: "uint64"
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "string",
+				name: "responseFieldName",
+				type: "string"
 			}
 		],
-		name: "isZKPRequestEnabled",
+		name: "getResponseFieldValue",
 		outputs: [
 			{
-				internalType: "bool",
+				internalType: "uint256",
 				name: "",
-				type: "bool"
+				type: "uint256"
 			}
 		],
 		stateMutability: "view",
@@ -53244,27 +54238,40 @@ var abi$2 = [
 	},
 	{
 		inputs: [
-		],
-		name: "owner",
-		outputs: [
+			{
+				internalType: "uint256",
+				name: "requestId",
+				type: "uint256"
+			},
 			{
 				internalType: "address",
-				name: "",
+				name: "sender",
 				type: "address"
 			}
 		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-		],
-		name: "pendingOwner",
+		name: "getResponseFields",
 		outputs: [
 			{
-				internalType: "address",
+				components: [
+					{
+						internalType: "string",
+						name: "name",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "value",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "rawValue",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IRequestValidator.ResponseField[]",
 				name: "",
-				type: "address"
+				type: "tuple[]"
 			}
 		],
 		stateMutability: "view",
@@ -53273,35 +54280,55 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "contract ICircuitValidator",
-				name: "validator",
-				type: "address"
+				internalType: "uint256",
+				name: "groupId",
+				type: "uint256"
 			}
 		],
-		name: "removeValidatorFromWhitelist",
+		name: "groupIdExists",
 		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
 		],
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
 		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "requestId",
+				type: "uint256"
+			}
 		],
-		name: "renounceOwnership",
+		name: "isRequestProofVerified",
 		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
 		],
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
 		inputs: [
 			{
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
+				internalType: "uint256",
+				name: "multiRequestId",
+				type: "uint256"
 			}
 		],
-		name: "requestIdExists",
+		name: "multiRequestIdExists",
 		outputs: [
 			{
 				internalType: "bool",
@@ -53315,53 +54342,48 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "uint64",
+				internalType: "uint256",
 				name: "requestId",
-				type: "uint64"
-			},
-			{
-				internalType: "address",
-				name: "requestOwner",
-				type: "address"
+				type: "uint256"
 			}
 		],
-		name: "setRequestOwner",
+		name: "requestIdExists",
 		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
 		],
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
 		inputs: [
-			{
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
-			},
 			{
 				components: [
 					{
 						internalType: "string",
-						name: "metadata",
+						name: "authMethod",
 						type: "string"
 					},
 					{
-						internalType: "contract ICircuitValidator",
+						internalType: "contract IAuthValidator",
 						name: "validator",
 						type: "address"
 					},
 					{
 						internalType: "bytes",
-						name: "data",
+						name: "params",
 						type: "bytes"
 					}
 				],
-				internalType: "struct IZKPVerifier.ZKPRequest",
-				name: "request",
+				internalType: "struct IVerifier.AuthMethod",
+				name: "authMethod",
 				type: "tuple"
 			}
 		],
-		name: "setZKPRequest",
+		name: "setAuthMethod",
 		outputs: [
 		],
 		stateMutability: "nonpayable",
@@ -53370,32 +54392,34 @@ var abi$2 = [
 	{
 		inputs: [
 			{
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
-			},
-			{
-				internalType: "uint256[]",
-				name: "inputs",
-				type: "uint256[]"
-			},
-			{
-				internalType: "uint256[2]",
-				name: "a",
-				type: "uint256[2]"
-			},
-			{
-				internalType: "uint256[2][2]",
-				name: "b",
-				type: "uint256[2][2]"
-			},
-			{
-				internalType: "uint256[2]",
-				name: "c",
-				type: "uint256[2]"
+				components: [
+					{
+						internalType: "uint256",
+						name: "multiRequestId",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256[]",
+						name: "requestIds",
+						type: "uint256[]"
+					},
+					{
+						internalType: "uint256[]",
+						name: "groupIds",
+						type: "uint256[]"
+					},
+					{
+						internalType: "bytes",
+						name: "metadata",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IVerifier.MultiRequest",
+				name: "multiRequest",
+				type: "tuple"
 			}
 		],
-		name: "submitZKPResponse",
+		name: "setMultiRequest",
 		outputs: [
 		],
 		stateMutability: "nonpayable",
@@ -53406,46 +54430,37 @@ var abi$2 = [
 			{
 				components: [
 					{
-						internalType: "uint64",
+						internalType: "uint256",
 						name: "requestId",
-						type: "uint64"
+						type: "uint256"
 					},
 					{
-						internalType: "bytes",
-						name: "zkProof",
-						type: "bytes"
+						internalType: "string",
+						name: "metadata",
+						type: "string"
+					},
+					{
+						internalType: "contract IRequestValidator",
+						name: "validator",
+						type: "address"
 					},
 					{
 						internalType: "bytes",
-						name: "data",
+						name: "params",
 						type: "bytes"
+					},
+					{
+						internalType: "address",
+						name: "owner",
+						type: "address"
 					}
 				],
-				internalType: "struct ZKPResponse[]",
-				name: "responses",
+				internalType: "struct IVerifier.Request[]",
+				name: "requests",
 				type: "tuple[]"
-			},
-			{
-				internalType: "bytes",
-				name: "crossChainProof",
-				type: "bytes"
-			}
-		],
-		name: "submitZKPResponseV2",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "newOwner",
-				type: "address"
 			}
 		],
-		name: "transferOwnership",
+		name: "setRequests",
 		outputs: [
 		],
 		stateMutability: "nonpayable",
@@ -53453,91 +54468,55 @@ var abi$2 = [
 	},
 	{
 		inputs: [
-			{
-				internalType: "address",
-				name: "sender",
-				type: "address"
-			},
-			{
-				internalType: "uint64[]",
-				name: "requestIds",
-				type: "uint64[]"
-			}
-		],
-		name: "verifyLinkedProofs",
-		outputs: [
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "uint64",
-				name: "requestId",
-				type: "uint64"
-			},
-			{
-				internalType: "uint256[]",
-				name: "inputs",
-				type: "uint256[]"
-			},
-			{
-				internalType: "uint256[2]",
-				name: "a",
-				type: "uint256[2]"
-			},
-			{
-				internalType: "uint256[2][2]",
-				name: "b",
-				type: "uint256[2][2]"
-			},
-			{
-				internalType: "uint256[2]",
-				name: "c",
-				type: "uint256[2]"
-			},
-			{
-				internalType: "address",
-				name: "sender",
-				type: "address"
-			}
-		],
-		name: "verifyZKPResponse",
-		outputs: [
 			{
 				components: [
 					{
 						internalType: "string",
-						name: "key",
+						name: "authMethod",
 						type: "string"
 					},
+					{
+						internalType: "bytes",
+						name: "proof",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IVerifier.AuthResponse",
+				name: "authResponse",
+				type: "tuple"
+			},
+			{
+				components: [
 					{
 						internalType: "uint256",
-						name: "inputValue",
+						name: "requestId",
 						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "proof",
+						type: "bytes"
+					},
+					{
+						internalType: "bytes",
+						name: "metadata",
+						type: "bytes"
 					}
 				],
-				internalType: "struct ICircuitValidator.KeyToInputValue[]",
-				name: "",
+				internalType: "struct IVerifier.Response[]",
+				name: "responses",
 				type: "tuple[]"
+			},
+			{
+				internalType: "bytes",
+				name: "crossChainProofs",
+				type: "bytes"
 			}
 		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-		],
-		name: "version",
+		name: "submitResponse",
 		outputs: [
-			{
-				internalType: "string",
-				name: "",
-				type: "string"
-			}
 		],
-		stateMutability: "pure",
+		stateMutability: "nonpayable",
 		type: "function"
 	}
 ];
@@ -53556,6 +54535,8 @@ var FunctionSignatures;
     FunctionSignatures["SubmitZKPResponseV1"] = "b68967e2";
     //function submitZKPResponseV2(tuple[](uint64 requestId,bytes zkProof,bytes data),bytes crossChainProof)
     FunctionSignatures["SubmitZKPResponseV2"] = "ade09fcd";
+    //function submitResponse(tuple(string authMethod,bytes proof),tuple(uint256 requestId,bytes proof,bytes metadata)[],bytes crossChainProof)
+    FunctionSignatures["SubmitResponse"] = "06c86a91";
 })(FunctionSignatures || (FunctionSignatures = {}));
 /**
  * OnChainZKPVerifier is a class that allows to interact with the OnChainZKPVerifier contract
@@ -53581,16 +54562,8 @@ class OnChainZKPVerifier {
         }
         const requestID = zkProofResponse.id;
         const inputs = zkProofResponse.pub_signals;
-        const payload = [
-            requestID,
-            inputs,
-            zkProofResponse.proof.pi_a.slice(0, 2),
-            [
-                [zkProofResponse.proof.pi_b[0][1], zkProofResponse.proof.pi_b[0][0]],
-                [zkProofResponse.proof.pi_b[1][1], zkProofResponse.proof.pi_b[1][0]]
-            ],
-            zkProofResponse.proof.pi_c.slice(0, 2)
-        ];
+        const preparedZkpProof = prepareZkpProof(zkProofResponse.proof);
+        const payload = [requestID, inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c];
         return payload;
     }
     /**
@@ -53642,25 +54615,69 @@ class OnChainZKPVerifier {
             const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
             response.set(txnHash, zkProofResponse);
         }
-        return response;
+        return response;
+    }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.submitZKPResponseV2}
+     */
+    async submitZKPResponseV2(ethSigner, txData, zkProofResponses) {
+        const chainConfig = this._configs.find((i) => i.chainId == txData.chain_id);
+        if (!chainConfig) {
+            throw new Error(`config for chain id ${txData.chain_id} was not found`);
+        }
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
+            throw new Error(`submitZKPResponseV2 function 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 provider = new JsonRpcProvider(chainConfig.url, chainConfig.chainId);
+        ethSigner = ethSigner.connect(provider);
+        const txDataArgs = await this.prepareTxArgsSubmitV2(txData, zkProofResponses);
+        const feeData = await provider.getFeeData();
+        const maxFeePerGas = chainConfig.maxFeePerGas
+            ? BigInt(chainConfig.maxFeePerGas)
+            : feeData.maxFeePerGas;
+        const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
+            ? BigInt(chainConfig.maxPriorityFeePerGas)
+            : feeData.maxPriorityFeePerGas;
+        const verifierContract = new Contract(txData.contract_address, abi$2);
+        const txRequestData = await verifierContract.submitZKPResponseV2.populateTransaction(...txDataArgs);
+        const request = {
+            to: txData.contract_address,
+            data: txRequestData.data,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+        };
+        let gasLimit;
+        try {
+            gasLimit = await ethSigner.estimateGas(request);
+        }
+        catch (e) {
+            gasLimit = maxGasLimit;
+        }
+        request.gasLimit = gasLimit;
+        const transactionService = new TransactionService(provider);
+        const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
+        return new Map().set(txnHash, zkProofResponses);
     }
     /**
-     * {@inheritDoc IOnChainZKPVerifier.submitZKPResponseV2}
+     * {@inheritDoc IOnChainVerifierMultiQuery.submitResponse}
      */
-    async submitZKPResponseV2(ethSigner, txData, zkProofResponses) {
+    async submitResponse(ethSigner, txData, authResponse, responses) {
         const chainConfig = this._configs.find((i) => i.chainId == txData.chain_id);
         if (!chainConfig) {
             throw new Error(`config for chain id ${txData.chain_id} was not found`);
         }
-        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
-            throw new Error(`submitZKPResponseV2 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitResponse) {
+            throw new Error(`submitResponse function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitResponse}' is supported.`);
         }
         if (!this._opts?.didResolverUrl) {
             throw new Error(`did resolver url required for crosschain verification`);
         }
         const provider = new JsonRpcProvider(chainConfig.url, chainConfig.chainId);
         ethSigner = ethSigner.connect(provider);
-        const txDataArgs = await this.prepareTxArgsSubmitV2(txData, zkProofResponses);
+        const txDataArgs = await this.prepareTxArgsSubmit(txData, authResponse, responses);
         const feeData = await provider.getFeeData();
         const maxFeePerGas = chainConfig.maxFeePerGas
             ? BigInt(chainConfig.maxFeePerGas)
@@ -53668,8 +54685,8 @@ class OnChainZKPVerifier {
         const maxPriorityFeePerGas = chainConfig.maxPriorityFeePerGas
             ? BigInt(chainConfig.maxPriorityFeePerGas)
             : feeData.maxPriorityFeePerGas;
-        const verifierContract = new Contract(txData.contract_address, abi$2);
-        const txRequestData = await verifierContract.submitZKPResponseV2.populateTransaction(...txDataArgs);
+        const verifierContract = new Contract(txData.contract_address, IVerifierABI);
+        const txRequestData = await verifierContract.submitResponse.populateTransaction(...txDataArgs);
         const request = {
             to: txData.contract_address,
             data: txRequestData.data,
@@ -53686,7 +54703,37 @@ class OnChainZKPVerifier {
         request.gasLimit = gasLimit;
         const transactionService = new TransactionService(provider);
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
-        return new Map().set(txnHash, zkProofResponses);
+        // return multiple responses for all the responses (single and grouped)
+        return new Map().set(txnHash, {
+            responses: responses,
+            authProofs: [authResponse],
+            crossChainProofs: [txDataArgs[2]]
+        });
+    }
+    static async prepareTxArgsSubmit(resolverUrl, txData, authResponse, responses) {
+        if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitResponse) {
+            throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitResponse}' is supported.`);
+        }
+        const gistUpdateArr = [];
+        const stateUpdateArr = [];
+        const payloadResponses = [];
+        // Process all the responses
+        for (const zkProof of responses) {
+            const { requestID, zkProofEncoded, metadata } = await this._processProof(zkProof);
+            payloadResponses.push({
+                requestId: requestID,
+                proof: zkProofEncoded,
+                metadata: metadata
+            });
+        }
+        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        return [authResponse, payloadResponses, crossChainProofs];
+    }
+    async prepareTxArgsSubmit(txData, authResponse, responses) {
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        return OnChainZKPVerifier.prepareTxArgsSubmit(this._opts.didResolverUrl, txData, authResponse, responses);
     }
     static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
         return [
@@ -53729,10 +54776,8 @@ class OnChainZKPVerifier {
                 });
                 continue;
             }
-            const zkProofEncoded = this.packZkpProof(inputs, zkProof.proof.pi_a.slice(0, 2), [
-                [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
-                [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
-            ], zkProof.proof.pi_c.slice(0, 2));
+            const preparedZkpProof = prepareZkpProof(zkProof.proof);
+            const zkProofEncoded = packZkpProof(inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
             const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
             const chainId = txData.chain_id;
             const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
@@ -53775,8 +54820,30 @@ class OnChainZKPVerifier {
         }
         return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
     }
-    static packZkpProof(inputs, a, b, c) {
-        return new AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    static async _processProof(zkProof) {
+        const requestID = zkProof.id;
+        const inputs = zkProof.pub_signals;
+        if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+            throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
+        }
+        const preparedZkpProof = prepareZkpProof(zkProof.proof);
+        const zkProofEncoded = packZkpProof(inputs, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
+        const metadataArr = [];
+        if (zkProof.vp) {
+            for (const key in zkProof.vp.verifiableCredential.credentialSubject) {
+                if (key === '@type') {
+                    continue;
+                }
+                const metadataValue = poseidon.hashBytes(byteEncoder.encode(JSON.stringify(zkProof.vp.verifiableCredential.credentialSubject[key])));
+                const bytesValue = byteEncoder.encode(metadataValue.toString());
+                metadataArr.push({
+                    key,
+                    value: bytesValue
+                });
+            }
+        }
+        const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+        return { requestID, zkProofEncoded, metadata };
     }
     static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
@@ -58343,129 +59410,6 @@ class CredentialStatusResolverRegistry {
     }
 }
 
-const IDEN3_PROTOCOL = 'https://iden3-communication.io/';
-const DIDCOMM_PROTOCOL = 'https://didcomm.org/';
-/**
- * Constants for Iden3 protocol
- */
-const PROTOCOL_MESSAGE_TYPE = Object.freeze({
-    // AuthorizationV2RequestMessageType defines auth request type of the communication protocol
-    AUTHORIZATION_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}authorization/1.0/request`,
-    // AuthorizationResponseMessageType defines auth response type of the communication protocol
-    AUTHORIZATION_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}authorization/1.0/response`,
-    // CredentialIssuanceRequestMessageType accepts request for credential creation
-    CREDENTIAL_ISSUANCE_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/issuance-request`,
-    // CredentialFetchRequestMessageType is type for request of credential generation
-    CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/fetch-request`,
-    // CredentialOfferMessageType is type of message with credential offering
-    CREDENTIAL_OFFER_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/offer`,
-    // CredentialIssuanceResponseMessageType is type for message with a credential issuance
-    CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/issuance-response`,
-    // CredentialRefreshMessageType is type for message with a credential issuance
-    CREDENTIAL_REFRESH_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/refresh`,
-    // DeviceRegistrationRequestMessageType defines device registration request type of the communication protocol
-    DEVICE_REGISTRATION_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}devices/1.0/registration`,
-    // MessageFetMessageFetchRequestMessageType defines message fetch request type of the communication protocol.
-    MESSAGE_FETCH_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}messages/1.0/fetch`,
-    // ProofGenerationRequestMessageType is type for request of proof generation
-    PROOF_GENERATION_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/request`,
-    // ProofGenerationResponseMessageType is type for response of proof generation
-    PROOF_GENERATION_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/response`,
-    // RevocationStatusRequestMessageType is type for request of revocation status
-    REVOCATION_STATUS_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}revocation/1.0/request-status`,
-    // RevocationStatusResponseMessageType is type for response with a revocation status
-    REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}revocation/1.0/status`,
-    // ContractInvokeRequestMessageType is type for request of contract invoke request
-    CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-request`,
-    // ContractInvokeResponseMessageType is type for response of contract invoke request
-    CONTRACT_INVOKE_RESPONSE_MESSAGE_TYPE: `${IDEN3_PROTOCOL}proofs/1.0/contract-invoke-response`,
-    // CredentialOnchainOfferMessageType is type of message with credential onchain offering
-    CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/1.0/onchain-offer`,
-    // ProposalRequestMessageType is type for proposal-request message
-    PROPOSAL_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/proposal-request`,
-    // ProposalMessageType is type for proposal message
-    PROPOSAL_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/proposal`,
-    // PaymentRequestMessageType is type for payment-request message
-    PAYMENT_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment-request`,
-    // PaymentMessageType is type for payment message
-    PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`,
-    // DiscoveryProtocolQueriesMessageType is type for didcomm discovery protocol queries
-    DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/queries`,
-    // DiscoveryProtocolDiscloseMessageType is type for didcomm discovery protocol disclose
-    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`,
-    // ProblemReportMessageType is type for didcomm problem report
-    PROBLEM_REPORT_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}report-problem/2.0/problem-report`
-});
-/**
- * Media types for iden3 comm communication protocol
- *
- * @enum {number}
- */
-var MediaType;
-(function (MediaType) {
-    MediaType["ZKPMessage"] = "application/iden3-zkp-json";
-    MediaType["PlainMessage"] = "application/iden3comm-plain-json";
-    MediaType["SignedMessage"] = "application/iden3comm-signed-json";
-})(MediaType || (MediaType = {}));
-const SUPPORTED_PUBLIC_KEY_TYPES = {
-    ES256K: [
-        'EcdsaSecp256k1VerificationKey2019',
-        /**
-         * Equivalent to EcdsaSecp256k1VerificationKey2019 when key is an ethereumAddress
-         */
-        'EcdsaSecp256k1RecoveryMethod2020',
-        'JsonWebKey2020'
-    ],
-    'ES256K-R': [
-        'EcdsaSecp256k1VerificationKey2019',
-        /**
-         * Equivalent to EcdsaSecp256k1VerificationKey2019 when key is an ethereumAddress
-         */
-        'EcdsaSecp256k1RecoveryMethod2020',
-        'JsonWebKey2020'
-    ]
-};
-var ProtocolVersion;
-(function (ProtocolVersion) {
-    ProtocolVersion["V1"] = "iden3comm/v1";
-})(ProtocolVersion || (ProtocolVersion = {}));
-var AcceptAuthCircuits;
-(function (AcceptAuthCircuits) {
-    AcceptAuthCircuits["AuthV2"] = "authV2";
-    AcceptAuthCircuits["AuthV3"] = "authV3";
-})(AcceptAuthCircuits || (AcceptAuthCircuits = {}));
-var AcceptJwzAlgorithms;
-(function (AcceptJwzAlgorithms) {
-    AcceptJwzAlgorithms["Groth16"] = "groth16";
-})(AcceptJwzAlgorithms || (AcceptJwzAlgorithms = {}));
-var AcceptJwsAlgorithms;
-(function (AcceptJwsAlgorithms) {
-    AcceptJwsAlgorithms["ES256K"] = "ES256K";
-    AcceptJwsAlgorithms["ES256KR"] = "ES256K-R";
-})(AcceptJwsAlgorithms || (AcceptJwsAlgorithms = {}));
-const defaultAcceptProfile = {
-    protocolVersion: ProtocolVersion.V1,
-    env: MediaType.ZKPMessage,
-    circuits: [AcceptAuthCircuits.AuthV2],
-    alg: [AcceptJwzAlgorithms.Groth16]
-};
-const DEFAULT_PROOF_VERIFY_DELAY = 1 * 60 * 60 * 1000; // 1 hour
-const DEFAULT_AUTH_VERIFY_DELAY = 5 * 60 * 1000; // 5 minutes
-
-var constants = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get AcceptAuthCircuits () { return AcceptAuthCircuits; },
-    get AcceptJwsAlgorithms () { return AcceptJwsAlgorithms; },
-    get AcceptJwzAlgorithms () { return AcceptJwzAlgorithms; },
-    DEFAULT_AUTH_VERIFY_DELAY: DEFAULT_AUTH_VERIFY_DELAY,
-    DEFAULT_PROOF_VERIFY_DELAY: DEFAULT_PROOF_VERIFY_DELAY,
-    get MediaType () { return MediaType; },
-    PROTOCOL_MESSAGE_TYPE: PROTOCOL_MESSAGE_TYPE,
-    get ProtocolVersion () { return ProtocolVersion; },
-    SUPPORTED_PUBLIC_KEY_TYPES: SUPPORTED_PUBLIC_KEY_TYPES,
-    defaultAcceptProfile: defaultAcceptProfile
-});
-
 /**
  * AgentResolver is a class that allows to interact with the issuer's agent to get revocation status.
  *
@@ -59404,125 +60348,31 @@ class NativeProver {
      * @param {string} circuitId - circuit id for proof generation
      * @returns `Promise<ZKProof>`
      */
-    async generate(inputs, circuitId) {
-        const circuitData = await this._circuitStorage.loadCircuitData(circuitId);
-        if (!circuitData.wasm) {
-            throw new Error(`wasm file doesn't exist for circuit ${circuitId}`);
-        }
-        const witnessCalculator = await witnessBuilder(circuitData.wasm);
-        const parsedData = JSON.parse(byteDecoder.decode(inputs));
-        const wtnsBytes = await witnessCalculator.calculateWTNSBin(parsedData, 0);
-        if (!circuitData.provingKey) {
-            throw new Error(`proving file doesn't exist for circuit ${circuitId}`);
-        }
-        const { proof, publicSignals } = await groth16.prove(circuitData.provingKey, wtnsBytes);
-        // we need to terminate curve manually
-        await this.terminateCurve();
-        return {
-            proof,
-            pub_signals: publicSignals
-        };
-    }
-    async terminateCurve() {
-        const curve = await getCurveFromName(NativeProver.curveName);
-        curve.terminate();
-    }
-}
-NativeProver.curveName = 'bn128';
-
-/**
- * creates empty basic message
- *
- * @returns BasicMessage
- */
-const basicMessageFactory = () => {
-    return {
-        id: '',
-        typ: '',
-        thid: '',
-        type: '',
-        body: {},
-        from: '',
-        to: ''
-    };
-};
-/**
- * create empty header stub
- *
- * @returns {HeaderStub}
- */
-const headerStubFactory = () => {
-    return {
-        typ: ''
-    };
-};
-
-// Envelope Errors
-// Token Errors
-const ErrUnknownCircuitID = "unknown circuit ID. can't verify msg sender";
-const ErrSenderNotUsedTokenCreation = 'sender of message is not used for jwz token creation';
-// ZKP-Packer Errors
-const ErrPackedWithUnsupportedCircuit = 'message was packed with unsupported circuit';
-const ErrProofIsInvalid = 'message proof is invalid';
-const ErrStateVerificationFailed = 'message state verification failed';
-const ErrNoProvingMethodAlg = 'unknown proving method algorithm';
-
-const objectIs = (obj, //eslint-disable-line @typescript-eslint/no-explicit-any
-targetObj //eslint-disable-line @typescript-eslint/no-explicit-any
-) => {
-    Object.keys(targetObj).forEach((prop) => {
-        if (!obj[prop]) {
-            return false;
-        }
-        if (typeof targetObj[prop] !== typeof obj[prop]) {
-            return false;
-        }
-    });
-    return true;
-};
-//eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isProtocolMessage = (message) => {
-    const basicMessage = basicMessageFactory();
-    Object.keys(basicMessage).forEach((prop) => {
-        if (!message[prop]) {
-            return false;
-        }
-        if (prop !== 'body') {
-            const res = typeof basicMessage[prop] ===
-                typeof message[prop]; //eslint-disable-line @typescript-eslint/no-explicit-any
-            if (!res) {
-                return false;
-            }
+    async generate(inputs, circuitId) {
+        const circuitData = await this._circuitStorage.loadCircuitData(circuitId);
+        if (!circuitData.wasm) {
+            throw new Error(`wasm file doesn't exist for circuit ${circuitId}`);
         }
-    });
-    return true;
-};
-/**
- * helper function to convert serialized JSON bytes to protocol message
- *
- * @param {Uint8Array} bytes
- * @returns  {BasicMessage}
- */
-const bytesToProtocolMessage = (bytes) => {
-    const str = byteDecoder.decode(bytes);
-    const message = JSON.parse(str);
-    if (!isProtocolMessage(message)) ;
-    return message;
-};
-/**
- * helper function to convert serialized JSON bytes to header stub
- * so we can work with know the media type of the message
- *
- * @param {Uint8Array} envelope
- * @returns {HeaderStub}
- */
-const bytesToHeaderStub = (envelope) => {
-    const tmpObj = headerStubFactory();
-    const str = byteDecoder.decode(envelope);
-    const message = JSON.parse(str);
-    if (!objectIs(message, tmpObj)) ;
-    return message;
-};
+        const witnessCalculator = await witnessBuilder(circuitData.wasm);
+        const parsedData = JSON.parse(byteDecoder.decode(inputs));
+        const wtnsBytes = await witnessCalculator.calculateWTNSBin(parsedData, 0);
+        if (!circuitData.provingKey) {
+            throw new Error(`proving file doesn't exist for circuit ${circuitId}`);
+        }
+        const { proof, publicSignals } = await groth16.prove(circuitData.provingKey, wtnsBytes);
+        // we need to terminate curve manually
+        await this.terminateCurve();
+        return {
+            proof,
+            pub_signals: publicSignals
+        };
+    }
+    async terminateCurve() {
+        const curve = await getCurveFromName(NativeProver.curveName);
+        curve.terminate();
+    }
+}
+NativeProver.curveName = 'bn128';
 
 /**
  * Basic package manager for iden3 communication protocol
@@ -59634,164 +60484,6 @@ class PackageManager {
     }
 }
 
-const DIDAuthenticationSection = 'authentication';
-const resolveVerificationMethods = (didDocument) => {
-    const vms = didDocument.verificationMethod || [];
-    // prioritize: first verification methods to be chosen are from `authentication` section.
-    const sortedVerificationMethods = (didDocument[DIDAuthenticationSection] || [])
-        .map((verificationMethod) => {
-        if (typeof verificationMethod === 'string') {
-            return vms.find((i) => i.id === verificationMethod);
-        }
-        return verificationMethod;
-    })
-        .filter((key) => key);
-    // add all other verification methods
-    for (let index = 0; index < vms.length; index++) {
-        const id = vms[index].id;
-        if (sortedVerificationMethods.findIndex((vm) => vm.id === id) === -1) {
-            sortedVerificationMethods.push(vms[index]);
-        }
-    }
-    return sortedVerificationMethods;
-};
-const extractPublicKeyBytes = (vm) => {
-    const isSupportedVmType = Object.keys(SUPPORTED_PUBLIC_KEY_TYPES).some((key) => SUPPORTED_PUBLIC_KEY_TYPES[key].includes(vm.type));
-    if (vm.publicKeyBase58 && isSupportedVmType) {
-        return { publicKeyBytes: base58ToBytes$1(vm.publicKeyBase58), kmsKeyType: KmsKeyType.Secp256k1 };
-    }
-    if (vm.publicKeyBase64 && isSupportedVmType) {
-        return {
-            publicKeyBytes: base64UrlToBytes(vm.publicKeyBase64),
-            kmsKeyType: KmsKeyType.Secp256k1
-        };
-    }
-    if (vm.publicKeyHex && isSupportedVmType) {
-        return { publicKeyBytes: hexToBytes$3(vm.publicKeyHex), kmsKeyType: KmsKeyType.Secp256k1 };
-    }
-    if (vm.publicKeyJwk &&
-        vm.publicKeyJwk.crv === 'secp256k1' &&
-        vm.publicKeyJwk.x &&
-        vm.publicKeyJwk.y) {
-        const [xHex, yHex] = [
-            base64UrlToBytes(vm.publicKeyJwk.x),
-            base64UrlToBytes(vm.publicKeyJwk.y)
-        ].map(bytesToHex$3);
-        const x = xHex.includes('0x') ? BigInt(xHex) : BigInt(`0x${xHex}`);
-        const y = yHex.includes('0x') ? BigInt(yHex) : BigInt(`0x${yHex}`);
-        return {
-            publicKeyBytes: secp256k1$1.ProjectivePoint.fromAffine({
-                x,
-                y
-            }).toRawBytes(false),
-            kmsKeyType: KmsKeyType.Secp256k1
-        };
-    }
-    return { publicKeyBytes: null };
-};
-
-function isProtocolVersion(value) {
-    return Object.values(ProtocolVersion).includes(value);
-}
-function isMediaType(value) {
-    return Object.values(MediaType).includes(value);
-}
-function isAcceptAuthCircuits(value) {
-    return Object.values(AcceptAuthCircuits).includes(value);
-}
-function isAcceptJwsAlgorithms(value) {
-    return Object.values(AcceptJwsAlgorithms).includes(value);
-}
-function isAcceptJwzAlgorithms(value) {
-    return Object.values(AcceptJwzAlgorithms).includes(value);
-}
-const buildAccept = (profiles) => {
-    const result = [];
-    for (const profile of profiles) {
-        let accept = `${profile.protocolVersion};env=${profile.env}`;
-        if (profile.circuits?.length) {
-            accept += `;circuitId=${profile.circuits.join(',')}`;
-        }
-        if (profile.alg?.length) {
-            accept += `;alg=${profile.alg.join(',')}`;
-        }
-        result.push(accept);
-    }
-    return result;
-};
-const parseAcceptProfile = (profile) => {
-    const params = profile.split(';');
-    if (params.length < 2) {
-        throw new Error('Invalid accept profile');
-    }
-    const protocolVersion = params[0].trim();
-    if (!isProtocolVersion(protocolVersion)) {
-        throw new Error(`Protocol version '${protocolVersion}' not supported`);
-    }
-    const envParam = params[1].split('=');
-    if (envParam.length !== 2) {
-        throw new Error(`Invalid accept profile 'env' parameter`);
-    }
-    const env = params[1].split('=')[1].trim();
-    if (!isMediaType(env)) {
-        throw new Error(`Envelop '${env}' not supported`);
-    }
-    const circuitsIndex = params.findIndex((i) => i.includes('circuitId='));
-    if (env !== MediaType.ZKPMessage && circuitsIndex > 0) {
-        throw new Error(`Circuits not supported for env '${env}'`);
-    }
-    let circuits = undefined;
-    if (circuitsIndex > 0) {
-        circuits = params[circuitsIndex]
-            .split('=')[1]
-            .split(',')
-            .map((i) => i.trim())
-            .map((i) => {
-            if (!isAcceptAuthCircuits(i)) {
-                throw new Error(`Circuit '${i}' not supported`);
-            }
-            return i;
-        });
-    }
-    const algIndex = params.findIndex((i) => i.includes('alg='));
-    let alg = undefined;
-    if (algIndex > 0) {
-        if (env === MediaType.ZKPMessage) {
-            alg = params[algIndex]
-                .split('=')[1]
-                .split(',')
-                .map((i) => {
-                i = i.trim();
-                if (!isAcceptJwzAlgorithms(i)) {
-                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
-                }
-                return i;
-            });
-        }
-        else if (env === MediaType.SignedMessage) {
-            alg = params[algIndex]
-                .split('=')[1]
-                .split(',')
-                .map((i) => {
-                i = i.trim();
-                if (!isAcceptJwsAlgorithms(i)) {
-                    throw new Error(`Algorithm '${i}' not supported for '${env}'`);
-                }
-                return i;
-            });
-        }
-        else {
-            throw new Error(`Algorithm not supported for '${env}'`);
-        }
-    }
-    return {
-        protocolVersion,
-        env,
-        circuits,
-        alg
-    };
-};
-
 const { getProvingMethod } = proving;
 /**
  * Handler to
@@ -60218,6 +60910,12 @@ var CredentialOfferStatus;
     CredentialOfferStatus["Rejected"] = "rejected";
 })(CredentialOfferStatus || (CredentialOfferStatus = {}));
 
+var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod["AUTHV2"] = "authV2";
+    AuthMethod["ETH_IDENTITY"] = "ethIdentity";
+})(AuthMethod || (AuthMethod = {}));
+
 /** @beta DiscoverFeatureQueryType is enum for query type fields */
 var DiscoverFeatureQueryType;
 (function (DiscoverFeatureQueryType) {
@@ -60311,6 +61009,59 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     }
     return zkpResponses;
 };
+/**
+ * Processes auth proof requests.
+ *
+ * @param to - The identifier of the recipient.
+ * @param proofService - The proof service.
+ * @param opts - Additional options for processing the requests.
+ * @returns A promise that resolves to an auth proof response.
+ */
+const processProofAuth = async (to, proofService, opts) => {
+    if (!opts.acceptProfile) {
+        opts.acceptProfile = defaultAcceptProfile;
+    }
+    if (!opts.skipRevocation) {
+        opts.skipRevocation = true;
+    }
+    switch (opts.acceptProfile.env) {
+        case MediaType.ZKPMessage:
+            if (!opts.acceptProfile.circuits) {
+                throw new Error('Circuit not specified in accept profile');
+            }
+            for (const circuitId of opts.acceptProfile.circuits) {
+                if (!opts.supportedCircuits.includes(circuitId)) {
+                    throw new Error(`Circuit ${circuitId} is not supported`);
+                }
+                const zkpRes = await proofService.generateAuthProof(circuitId, to, { challenge: opts.challenge, skipRevocation: opts.skipRevocation });
+                switch (circuitId) {
+                    case CircuitId.AuthV2: {
+                        const preparedZkpProof = prepareZkpProof(zkpRes.proof);
+                        const zkProofEncoded = packZkpProof(zkpRes.pub_signals, preparedZkpProof.a, preparedZkpProof.b, preparedZkpProof.c);
+                        return {
+                            authMethod: AuthMethod.AUTHV2,
+                            proof: zkProofEncoded
+                        };
+                    }
+                }
+            }
+            throw new Error(`Auth method is not supported`);
+        case MediaType.SignedMessage:
+            if (!opts.acceptProfile.alg || opts.acceptProfile.alg.length === 0) {
+                throw new Error('Algorithm not specified');
+            }
+            if (opts.acceptProfile.alg[0] === AcceptJwsAlgorithms.ES256KR) {
+                const ethIdProof = packEthIdentityProof(to);
+                return {
+                    authMethod: AuthMethod.ETH_IDENTITY,
+                    proof: ethIdProof
+                };
+            }
+            throw new Error(`Algorithm ${opts.acceptProfile.alg[0]} not supported`);
+        default:
+            throw new Error('Accept env not supported');
+    }
+};
 /**
  * Verifies that the expires_time field of a message is not in the past. Throws an error if it is.
  *
@@ -60321,6 +61072,9 @@ const verifyExpiresTime = (message) => {
         throw new Error('Message expired');
     }
 };
+const packEthIdentityProof = (did) => {
+    return `0x${bytesToHex$3(BytesHelper.intToBytes(DID.idFromDID(did).bigInt()))}`;
+};
 
 /**
  * Base implementation of protocol message handler
@@ -60595,7 +61349,7 @@ class AuthHandler extends AbstractMessageHandler {
         // group requests by query group id
         for (const proofRequest of requestScope) {
             const groupId = proofRequest.query.groupId;
-            const proofResp = responseScope.find((resp) => resp.id === proofRequest.id);
+            const proofResp = responseScope.find((resp) => resp.id.toString() === proofRequest.id.toString());
             if (!proofResp) {
                 throw new Error(`proof is not given for requestId ${proofRequest.id}`);
             }
@@ -60953,6 +61707,7 @@ class ContractRequestHandler extends AbstractMessageHandler {
      * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
      * @param {IProofService} _proofService -  proof service to verify zk proofs
      * @param {IOnChainZKPVerifier} _zkpVerifier - zkp verifier to submit response
+     * @param {IOnChainVerifierMultiQuery} _verifierMultiQuery - verifier multi-query to submit response
      *
      */
     constructor(_packerMgr, _proofService, _zkpVerifier) {
@@ -60964,7 +61719,12 @@ class ContractRequestHandler extends AbstractMessageHandler {
             CircuitId.AuthV2,
             CircuitId.AtomicQueryMTPV2OnChain,
             CircuitId.AtomicQuerySigV2OnChain,
-            CircuitId.AtomicQueryV3OnChain
+            CircuitId.AtomicQueryV3OnChain,
+            // Now we support off-chain circuits on-chain
+            // TODO: We need to create validators for them
+            CircuitId.AuthV2,
+            CircuitId.AtomicQueryV3,
+            CircuitId.LinkedMultiQuery10
         ];
     }
     async handle(message, ctx) {
@@ -61000,19 +61760,64 @@ class ContractRequestHandler extends AbstractMessageHandler {
         });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
         switch (methodId) {
-            case FunctionSignatures.SubmitZKPResponseV2:
-                return this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+            case FunctionSignatures.SubmitZKPResponseV2: {
+                const txHashZkpResponsesMap = await this._zkpVerifier.submitZKPResponseV2(ethSigner, message.body.transaction_data, zkpResponses);
+                const response = new Map();
+                for (const [txHash, zkpResponses] of txHashZkpResponsesMap) {
+                    response.set(txHash, { responses: zkpResponses });
+                }
+                return response;
+            }
             case FunctionSignatures.SubmitZKPResponseV1: {
                 const txHashZkpResponseMap = await this._zkpVerifier.submitZKPResponse(ethSigner, message.body.transaction_data, zkpResponses);
                 const response = new Map();
                 for (const [txHash, zkpResponse] of txHashZkpResponseMap) {
-                    response.set(txHash, [zkpResponse]);
+                    response.set(txHash, { responses: [zkpResponse] });
                 }
                 return response;
             }
+            case FunctionSignatures.SubmitResponse: {
+                // We need to
+                // 1. Generate auth proof from message.body.accept -> authResponse
+                // 2. Generate proofs for each query in scope -> zkpResponses
+                // Build auth response from accept
+                if (!message.to) {
+                    throw new Error(`failed message. empty 'to' field`);
+                }
+                // Get first supported accept profile and pass it to processProofAuth
+                const acceptProfile = this.getFirstSupportedProfile(PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE, message.body.accept);
+                const identifier = DID.parse(message.to);
+                const authResponse = await processProofAuth(identifier, this._proofService, {
+                    supportedCircuits: this._supportedCircuits,
+                    acceptProfile,
+                    challenge: challenge,
+                    skipRevocation: true
+                });
+                return this._zkpVerifier.submitResponse(ethSigner, message.body.transaction_data, authResponse, zkpResponses);
+            }
             default:
-                throw new Error(`Not supported method id. Only '${FunctionSignatures.SubmitZKPResponseV1} and ${FunctionSignatures.SubmitZKPResponseV2} are supported.'`);
+                throw new Error(`Not supported method id. Only '${FunctionSignatures.SubmitZKPResponseV1}, ${FunctionSignatures.SubmitZKPResponseV2} and ${FunctionSignatures.SubmitResponse} are supported.'`);
+        }
+    }
+    getFirstSupportedProfile(responseType, profile) {
+        if (profile?.length) {
+            for (const acceptProfileString of profile) {
+                // 1. check protocol version
+                const acceptProfile = parseAcceptProfile(acceptProfileString);
+                const responseTypeVersion = Number(responseType.split('/').at(-2));
+                if (acceptProfile.protocolVersion !== ProtocolVersion.V1 ||
+                    (acceptProfile.protocolVersion === ProtocolVersion.V1 &&
+                        (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
+                    continue;
+                }
+                // 2. check packer support
+                if (this._packerMgr.isProfileSupported(acceptProfile.env, acceptProfileString)) {
+                    return acceptProfile;
+                }
+            }
         }
+        // if we don't have supported profiles, we use default
+        return defaultAcceptProfile;
     }
     /**
      * unpacks contract-invoke request
@@ -61034,7 +61839,7 @@ class ContractRequestHandler extends AbstractMessageHandler {
      * @private
      * @beta
      * @param {ContractInvokeRequest} request - ContractInvokeRequest
-     * @param { Map<string, ZeroKnowledgeProofResponse[]>} responses - map tx hash to array of ZeroKnowledgeProofResponses
+     * @param { Map<string, ZeroKnowledgeInvokeResponse>} responses - map tx hash to array of ZeroKnowledgeInvokeResponse
      * @returns `Promise<ContractInvokeResponse>`
      */
     async createContractInvokeResponse(request, txHashToZkpResponseMap) {
@@ -61051,12 +61856,17 @@ class ContractRequestHandler extends AbstractMessageHandler {
             created_time: getUnixTimestamp(new Date())
         };
         for (const [txHash, zkpResponses] of txHashToZkpResponseMap) {
-            for (const zkpResponse of zkpResponses) {
+            for (const zkpResponse of zkpResponses.responses) {
                 contractInvokeResponse.body.scope.push({
                     txHash,
                     ...zkpResponse
                 });
             }
+            contractInvokeResponse.body = {
+                ...contractInvokeResponse.body,
+                crossChainProofs: zkpResponses.crossChainProofs ?? [],
+                authProofs: zkpResponses.authProofs ?? []
+            };
         }
         return contractInvokeResponse;
     }
@@ -62322,6 +63132,7 @@ class InputGenerator {
             return circuitInputs.inputsMarshal();
         };
         this.credentialAtomicQueryV3OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const id = DID.idFromDID(identifier);
             const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
             circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
             let proofType;
@@ -62371,20 +63182,17 @@ class InputGenerator {
             const isEthIdentity = isEthereumIdentity(identifier);
             circuitInputs.isBJJAuthEnabled = isEthIdentity ? 0 : 1;
             circuitInputs.challenge = BigInt(params.challenge ?? 0);
-            const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
-            const id = DID.idFromDID(genesisDID);
             const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
             const gistProof = toGISTProof(stateProof);
             circuitInputs.gistProof = gistProof;
             // auth inputs
             if (circuitInputs.isBJJAuthEnabled === 1) {
-                const authPrepared = await this.prepareAuthBJJCredential(genesisDID);
+                const authPrepared = await this.prepareAuthBJJCredential(identifier);
                 const authClaimData = await this.newCircuitClaimData({
                     credential: authPrepared.credential,
                     credentialCoreClaim: authPrepared.coreClaim
                 });
                 const signature = await this._identityWallet.signChallenge(circuitInputs.challenge, authPrepared.credential);
-                circuitInputs.profileNonce = BigInt(authProfileNonce);
                 circuitInputs.authClaim = authClaimData.claim;
                 circuitInputs.authClaimIncMtp = authClaimData.proof;
                 circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
@@ -63281,6 +64089,32 @@ class ProofService {
             pub_signals
         };
     }
+    /** {@inheritdoc IProofService.generateAuthProof} */
+    async generateAuthProof(circuitId, identifier, opts) {
+        if (!opts) {
+            opts = {
+                skipRevocation: false,
+                challenge: 0n
+            };
+        }
+        let zkProof;
+        switch (circuitId) {
+            case CircuitId.AuthV2:
+                {
+                    const challenge = opts.challenge
+                        ? BytesHelper.intToBytes(opts.challenge).reverse()
+                        : new Uint8Array(32);
+                    zkProof = await this.generateAuthV2Proof(challenge, identifier);
+                }
+                return {
+                    circuitId: circuitId,
+                    proof: zkProof.proof,
+                    pub_signals: zkProof.pub_signals
+                };
+            default:
+                throw new Error(`CircuitId ${circuitId} is not supported`);
+        }
+    }
     /** {@inheritdoc IProofService.transitState} */
     async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, // for compatibility with previous versions we leave this parameter
     ethSigner) {
@@ -64136,5 +64970,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DiscoverFeatureQueryType, DiscoveryProtocolFeatureType, DiscoveryProtocolHandler, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedDataFormat, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createDiscoveryFeatureDiscloseMessage, createDiscoveryFeatureQueryMessage, createPayment, createPaymentRequest, createProblemReportMessage, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
+export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthMethod, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DiscoverFeatureQueryType, DiscoveryProtocolFeatureType, DiscoveryProtocolHandler, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedDataFormat, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createDiscoveryFeatureDiscloseMessage, createDiscoveryFeatureQueryMessage, createPayment, createPaymentRequest, createProblemReportMessage, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, packEthIdentityProof, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processProofAuth, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map