iden3 · AndriianChestnykh · Oct 24, 2024 · Oct 21, 2024 · Oct 21, 2024 · Oct 21, 2024
diff --git a/README.md b/README.md
@@ -135,6 +135,15 @@ Run tests with gas statistics and costs report:
 COINMARKETCAP_KEY=<<your coinmarketcap key>> REPORT_GAS=true npx hardhat test 
 ```
 
+## Circuits needed for some maintenance and upgrade scripts
+For some of the scripts you need to download the zk circuits for generation and verification of the proofs.
+Download the zk circuits into `./scripts/upgrade/verifiers/helpers/circuits` by running `./scripts/upgrade/verifiers/helpers/dl_circuits.sh`. This will download the latest files from `https://iden3-circuits-bucket.s3.eu-west-1.amazonaws.com/latest.zip`
+
+    ```bash
+    cd ./scripts/upgrade/verifiers/helpers 
+    ./dl_circuits.sh
+    ```
+
 ## Other Hardhat commands
 
 ```shell

diff --git a/helpers/DeployHelper.ts b/helpers/DeployHelper.ts
@@ -883,14 +883,14 @@ export class DeployHelper {
     let verifier: Contract;
     try {
       verifier = await upgrades.upgradeProxy(verifierAddress, VerifierFactory, {
-        unsafeAllowLinkedLibraries: true,
+        unsafeAllow: ["external-library-linking"],
       });
       await verifier.waitForDeployment();
     } catch (e) {
       this.log("Error upgrading proxy. Forcing import...");
       await upgrades.forceImport(verifierAddress, VerifierFactory);
       verifier = await upgrades.upgradeProxy(verifierAddress, VerifierFactory, {
-        unsafeAllowLinkedLibraries: true,
+        unsafeAllow: ["external-library-linking"],
         redeployImplementation: "always",
       });
       await verifier.waitForDeployment();

diff --git a/helpers/constants.ts b/helpers/constants.ts
@@ -1,6 +1,8 @@
 // HARDHAT network Oracle signing address
 import { ethers } from "hardhat";
 
+export const DEFAULT_MNEMONIC = "test test test test test test test test test test test junk";
+
 const ORACLE_SIGNING_ADDRESS_HARDHAT = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
 // TEST networks Oracle signing address (For now we will use in testnets the same production signing address)
 export const ORACLE_SIGNING_ADDRESS_TEST = "0x3e1cFE1b83E7C1CdB0c9558236c1f6C7B203C34e";
@@ -91,6 +93,10 @@ export const networks = Object.freeze({
 export const STATE_ADDRESS_POLYGON_AMOY = "0x1a4cC30f2aA0377b0c3bc9848766D90cb4404124";
 export const STATE_ADDRESS_POLYGON_MAINNET = "0x624ce98D2d27b20b8f8d521723Df8fC4db71D79D";
 
+export const CIRCUIT_ID_MTP_V2 = "credentialAtomicQueryMTPV2OnChain";
+export const CIRCUIT_ID_SIG_V2 = "credentialAtomicQuerySigV2OnChain";
+export const CIRCUIT_ID_V3 = "credentialAtomicQueryV3OnChain-beta.1";
+
 export const VALIDATOR_TYPES = Object.freeze({
   MTP_V2: "mtpV2",
   SIG_V2: "sigV2",
@@ -327,4 +333,9 @@ export const contractsInfo = Object.freeze({
       libraries: {},
     },
   },
+  EMBEDDED_ZKP_VERIFIER_WRAPPER: {
+    name: "EmbeddedZKPVerifierWrapper",
+    unifiedAddress: "",
+    create2Calldata: "",
+  },
 });
diff --git a/helpers/helperUtils.ts b/helpers/helperUtils.ts
@@ -81,6 +81,9 @@ export async function verifyContract(
     libraries: any;
   },
 ): Promise<boolean> {
+  if (hre.network.name === "localhost") {
+    return true;
+  }
   // When verifying if the proxy contract is not verified yet we need to pass the arguments
   // for the proxy contract first, then for proxy admin and finally for the implementation contract
   if (opts.constructorArgsProxy) {

diff --git a/package.json b/package.json
@@ -147,6 +147,8 @@
     "add:validators:universal:verifier:localhost": "npx hardhat run scripts/maintenance/addValidatorsToUniversalVerifier.ts --network localhost",
     "add:validators:universal:verifier:polygon-amoy": "npx hardhat run scripts/maintenance/addValidatorsToUniversalVerifier.ts --network polygon-amoy",
     "payment:set-payment-value:polygon-amoy": "npx hardhat run scripts/maintenance/setPaymentValue.ts --network polygon-amoy",
+    "set:oracle:signing:address:polygon-amoy": "npx hardhat run scripts/maintenance/setOracleSigningAddress.ts --network polygon-amoy",   
9E81
 
+    "set:oracle:signing:address:polygon-mainnet": "npx hardhat run scripts/maintenance/setOracleSigningAddress.ts --network polygon-mainnet",    
     "verify:polygon-mainnet": "npx hardhat run scripts/maintenance/verifyEtherescan.js --network polygon-mainnet",
     "lint:contracts": "npx solhint contracts/**/*.sol",
     "prettier:contracts": "prettier --write --plugin=prettier-plugin-solidity 'contracts/**/*.sol'",

diff --git a/scripts/deploy/deployCrossChainVerifierWithRequests.ts b/scripts/deploy/deployCrossChainVerifierWithRequests.ts
@@ -17,6 +17,7 @@ import { Merklizer } from "@iden3/js-jsonld-merklization";
 import path from "path";
 import fs from "fs";
 import { Operators } from "@0xpolygonid/js-sdk";
+import { CIRCUIT_ID_MTP_V2, CIRCUIT_ID_SIG_V2, CIRCUIT_ID_V3 } from "../../helpers/constants";
 
 const removePreviousIgnitionFiles = true;
 
@@ -109,7 +110,7 @@ async function main() {
     value: [await Merklizer.hashValue("http://www.w3.org/2001/XMLSchema#boolean", true)],
     slotIndex: 0,
     queryHash: "",
-    circuitIds: ["credentialAtomicQueryV3OnChain-beta.1"],
+    circuitIds: [CIRCUIT_ID_V3],
     allowedIssuers: [],
     skipClaimRevocationCheck: false,
     verifierID: verifierId.bigInt(),
@@ -194,7 +195,7 @@ async function main() {
     value: [],
     slotIndex: 0,
     queryHash: "",
-    circuitIds: ["credentialAtomicQueryV3OnChain-beta.1"],
+    circuitIds: [CIRCUIT_ID_V3],
     allowedIssuers: [],
     skipClaimRevocationCheck: false,
     verifierID: verifierId.bigInt(),
@@ -279,7 +280,7 @@ async function main() {
     operator: Operators.LT,
     slotIndex: 0,
     value: [20020101, ...new Array(63).fill(0)], // for operators 1-3 only first value matters
-    circuitIds: ["credentialAtomicQuerySigV2OnChain"],
+    circuitIds: [CIRCUIT_ID_SIG_V2],
     skipClaimRevocationCheck: false,
     claimPathNotExists: 0,
   };
@@ -309,7 +310,7 @@ async function main() {
       },
       scope: [
         {
-          circuitId: "credentialAtomicQuerySigV2OnChain",
+          circuitId: CIRCUIT_ID_SIG_V2,
           id: requestId_Sig,
           query: {
             allowedIssuers: ["*"],
@@ -347,7 +348,7 @@ async function main() {
 
   console.log("================= setZKPRequest MTP V2 ===================");
 
-  query.circuitIds = ["credentialAtomicQueryMTPV2OnChain"];
+  query.circuitIds = [CIRCUIT_ID_MTP_V2];
   data = packValidatorParams(query);
   const requestId_Mtp = 2;
 
@@ -367,7 +368,7 @@ async function main() {
       },
       scope: [
         {
-          circuitId: "credentialAtomicQuerySigV2OnChain",
+          circuitId: CIRCUIT_ID_SIG_V2,
           id: requestId_Mtp,
           query: {
             allowedIssuers: ["*"],
@@ -415,7 +416,7 @@ async function main() {
     value: [20020101, ...new Array(63).fill(0)], // for operators 1-3 only first value matters
     slotIndex: 0,
     queryHash: "",
-    circuitIds: ["credentialAtomicQueryV3OnChain-beta.1"],
+    circuitIds: [CIRCUIT_ID_V3],
     allowedIssuers: [],
     skipClaimRevocationCheck: false,
     verifierID: verifierId.bigInt(),

diff --git a/scripts/maintenance/checkEmbeddedZKPVerifier.ts b/scripts/maintenance/checkEmbeddedZKPVerifier.ts
@@ -0,0 +1,70 @@
+import { getStateContractAddress, Logger } from "../../helpers/helperUtils";
+import { contractsInfo } from "../../helpers/constants";
+import hre, { ethers } from "hardhat";
+import {
+  setZKPRequest_KYCAgeCredential,
+  submitZKPResponses_KYCAgeCredential,
+} from "../upgrade/verifiers/helpers/testVerifier";
+import { Contract } from "ethers";
+
+// Replace these addresses with the ones you want to test
+const embeddedZKPVerifierAddress = "<put the embedded ZKP verifier address here>";
+const validatorSigV2Address = "<put the validator sig v2 address here>";
+const validatorMTPV2Address = "<put the validator mtp v2 address here>";
+const validatorV3Address = "<put the validator v3 address here>";
+
+async function testVerification(verifier: Contract) {
+  const requestId_V3 = 7254189;
+  await setZKPRequest_KYCAgeCredential(requestId_V3, verifier, validatorV3Address, "v3");
+  await submitZKPResponses_KYCAgeCredential(requestId_V3, verifier, "v3", {
+    stateContractAddress: getStateContractAddress(),
+    verifierContractAddress: await verifier.getAddress(),
+    checkSubmitZKResponseV2: false,
+  });
+
+  const requestId_SigV2 = 7254190;
+  await setZKPRequest_KYCAgeCredential(requestId_SigV2, verifier, validatorSigV2Address, "sigV2");
+  await submitZKPResponses_KYCAgeCredential(requestId_SigV2, verifier, "sigV2", {
+    stateContractAddress: getStateContractAddress(),
+    verifierContractAddress: await verifier.getAddress(),
+    checkSubmitZKResponseV2: false,
+  });
+
+  const requestId_MTPV2 = 7254191;
+  await setZKPRequest_KYCAgeCredential(requestId_MTPV2, verifier, validatorMTPV2Address, "mtpV2");
+  await submitZKPResponses_KYCAgeCredential(requestId_MTPV2, verifier, "mtpV2", {
+    stateContractAddress: getStateContractAddress(),
+    verifierContractAddress: await verifier.getAddress(),
+    checkSubmitZKResponseV2: false,
+  });
+}
+
+async function main() {
+  console.log(
+    `\nChecking EmbeddedZKPVerifier verification on ${hre.network.name} with address ${embeddedZKPVerifierAddress}...`,
+  );
+
+  const embeddedZKPVerifier = await ethers.getContractAt(
+    contractsInfo.EMBEDDED_ZKP_VERIFIER_WRAPPER.name,
+    embeddedZKPVerifierAddress,
+  );
+
+  try {
+    await testVerification(embeddedZKPVerifier);
+    Logger.success(
+      `${hre.network.name} embedded ZKP Verifier onchain ${embeddedZKPVerifierAddress} verified`,
+    );
+  } catch (error) {
+    console.error(error);
+    Logger.error(
+      `${hre.network.name} embedded ZKP Verifier onchain ${embeddedZKPVerifierAddress} not verified`,
+    );
+  }
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/scripts/maintenance/checkUniversalVerifierSingleNetwork.ts b/scripts/maintenance/checkUniversalVerifierSingleNetwork.ts
@@ -0,0 +1,70 @@
+import { getStateContractAddress, Logger } from "../../helpers/helperUtils";
+import { contractsInfo } from "../../helpers/constants";
+import hre, { ethers } from "hardhat";
+import {
+  setZKPRequest_KYCAgeCredential,
+  submitZKPResponses_KYCAgeCredential,
+} from "../upgrade/verifiers/helpers/testVerifier";
+import { Contract } from "ethers";
+
+// Replace these addresses with the ones you want to test
+const universalVerifierAddress = contractsInfo.UNIVERSAL_VERIFIER.unifiedAddress;
+const validatorSigV2Address = contractsInfo.VALIDATOR_SIG.unifiedAddress;
+const validatorMTPV2Address = contractsInfo.VALIDATOR_MTP.unifiedAddress;
+const validatorV3Address = contractsInfo.VALIDATOR_V3.unifiedAddress;
+
+async function testVerification(verifier: Contract) {
+  const requestId_V3 = 7254189;
+  await setZKPRequest_KYCAgeCredential(requestId_V3, verifier, validatorV3Address, "v3");
+  await submitZKPResponses_KYCAgeCredential(requestId_V3, verifier, "v3", {
+    stateContractAddress: getStateContractAddress(),
+    verifierContractAddress: await verifier.getAddress(),
+    checkSubmitZKResponseV2: false,
+  });
+
+  const requestId_SigV2 = 7254190;
+  await setZKPRequest_KYCAgeCredential(requestId_SigV2, verifier, validatorSigV2Address, "sigV2");
+  await submitZKPResponses_KYCAgeCredential(requestId_SigV2, verifier, "sigV2", {
+    stateContractAddress: getStateContractAddress(),
+    verifierContractAddress: await verifier.getAddress(),
+    checkSubmitZKResponseV2: false,
+  });
+
+  const requestId_MTPV2 = 7254191;
+  await setZKPRequest_KYCAgeCredential(requestId_MTPV2, verifier, validatorMTPV2Address, "mtpV2");
+  await submitZKPResponses_KYCAgeCredential(requestId_MTPV2, verifier, "mtpV2", {
+    stateContractAddress: getStateContractAddress(),
+    verifierContractAddress: await verifier.getAddress(),
+    checkSubmitZKResponseV2: false,
+  });
+}
+
+async function main() {
+  console.log(
+    `\nChecking UniversalVerifier verification on ${hre.network.name} with address ${universalVerifierAddress}...`,
+  );
+
+  const universalVerifier = await ethers.getContractAt(
+    contractsInfo.UNIVERSAL_VERIFIER.name,
+    universalVerifierAddress,
+  );
+
+  try {
+    await testVerification(universalVerifier);
+    Logger.success(
+      `${hre.network.name} Universal Verifier onchain ${universalVerifierAddress} verified`,
+    );
+  } catch (error) {
+    console.error(error);
+    Logger.error(
+      `${hre.network.name} Universal Verifier onchain ${universalVerifierAddress} not verified`,
+    );
+  }
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/scripts/maintenance/multi-chain/checkIdTypes.ts b/scripts/maintenance/multi-chain/checkIdTypes.ts
@@ -4,9 +4,11 @@ import {
   isContract,
   Logger,
 } from "../../../helpers/helperUtils";
-import { contractsInfo, networks } from "../../../helpers/constants";
+import { contractsInfo, DEFAULT_MNEMONIC, networks } from "../../../helpers/constants";
 import { ethers } from "hardhat";
 
+const mnemonicWallet = ethers.Wallet.fromPhrase(DEFAULT_MNEMONIC);
+
 async function main() {
   const providers = getProviders();
 
@@ -25,7 +27,7 @@ async function main() {
     if (!(await isContract(stateContractAddress, jsonRpcProvider))) {
       defaultIdTypeIsValid = false;
     } else {
-      const wallet = new ethers.Wallet(process.env.PRIVATE_KEY as string, jsonRpcProvider);
+      const wallet = new ethers.Wallet(mnemonicWallet.privateKey, jsonRpcProvider);
       const state = await ethers.getContractAt(
         contractsInfo.STATE.name,
         stateContractAddress,

diff --git a/scripts/maintenance/multi-chain/checkOracleSigningAddress.ts b/scripts/maintenance/multi-chain/checkOracleSigningAddress.ts
@@ -4,24 +4,32 @@ import {
   isContract,
   Logger,
 } from "../../../helpers/helperUtils";
-import { contractsInfo, ORACLE_SIGNING_ADDRESS_PRODUCTION } from "../../../helpers/constants";
+import {
+  contractsInfo,
+  DEFAULT_MNEMONIC,
+  ORACLE_SIGNING_ADDRESS_PRODUCTION,
+} from "../../../helpers/constants";
 import { ethers } from "hardhat";
 
+const mnemonicWallet = ethers.Wallet.fromPhrase(DEFAULT_MNEMONIC);
+
 async function main() {
   const providers = getProviders();
 
   for (const provider of providers) {
     const jsonRpcProvider = new ethers.JsonRpcProvider(provider.rpcUrl);
 
-    const stateContractAddress = getStateContractAddress();
+    const stateContractAddress = getStateContractAddress(
+      Number((await jsonRpcProvider.getNetwork()).chainId),
+    );
 
     let oracleSigningAddressIsValid = true;
     const defaultOracleSigningAddress = ORACLE_SIGNING_ADDRESS_PRODUCTION; // production signing address
 
     if (!(await isContract(stateContractAddress, jsonRpcProvider))) {
       oracleSigningAddressIsValid = false;
     } else {
-      const wallet = new ethers.Wallet(process.env.PRIVATE_KEY as string, jsonRpcProvider);
+      const wallet = new ethers.Wallet(mnemonicWallet.privateKey, jsonRpcProvider);
       const state = await ethers.getContractAt(
         contractsInfo.STATE.name,
         stateContractAddress,

diff --git a/scripts/maintenance/multi-chain/checkUniversalVerifierVerification.ts b/scripts/maintenance/multi-chain/checkUniversalVerifierVerification.ts
@@ -14,16 +14,21 @@ async function testVerification(
   wallet: Wallet,
 ) {
   const requestId = 7254189;
-  await setZKPRequest_KYCAgeCredential(requestId, verifier, validatorV3Address, provider);
-  await submitZKPResponses_KYCAgeCredential(requestId, verifier, {
+  await setZKPRequest_KYCAgeCredential(requestId, verifier, validatorV3Address, "v3", provider);
+  await submitZKPResponses_KYCAgeCredential(requestId, verifier, "v3", {
     stateContractAddress: getStateContractAddress(Number((await provider.getNetwork()).chainId)),
-    verifierContractAddress: contractsInfo.UNIVERSAL_VERIFIER.unifiedAddress,
     provider,
     signer: wallet,
+    checkSubmitZKResponseV2: true,
   });
 }
 
 async function main() {
+  if (!ethers.isAddress(process.env.PRIVATE_KEY)) {
+    throw new Error(
+      "PRIVATE_KEY is not set. You need to config it in .env file to be able to check the verification in all the networks automatically.\nIf you need only to check it in one network then use 'npx hardhat run scripts/maintenance/checkUniversalVerifierSingleNetwork.ts --network <network>'.",
+    );
+  }
   const providers = getProviders();
 
   const networksVerificationOK: string[] = [];