github/self
1
1
Fork 0
mirror of https://github.com/selfxyz/self.git synced 2026-01-10 07:08:10 -05:00
Code Issues Packages Projects Releases Wiki Activity

preparation for OneTimeVerification.ts

Browse Source
This commit is contained in:
motemotech
2024-10-09 17:16:22 +09:00
parent 5e215ef6cd
commit 946d4c591c
9 changed files with 619 additions and 497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
circuits/scripts/download_circuits_from_aws.sh
View File

@@ -42,6 +42,9 @@ download_and_compile_circuit() {
--O1 --wasm \
--output build/fromAWS
echo "Exporting vkey: $circuit_name"
snarkjs zkey export verificationkey build/fromAWS/${circuit_name}.zkey build/fromAWS/${circuit_name}_vkey.json
if [ $? -eq 0 ]; then
echo "Successfully compiled $circuit_name"
# Keep only the wasm file and remove other generated files
@@ -52,6 +55,7 @@ download_and_compile_circuit() {
else
echo "Failed to compile $circuit_name"
fi
else
echo "Failed to download $circuit_name"
fi

3
common/src/constants/contractConstants.ts
View File

@@ -22,3 +22,6 @@ export const PROVE_RSA_SCOPE_INDEX = 50;
export const DSC_BLINDED_DSC_COMMITMENT_INDEX = 0;
// Enum in VerifiersManager.sol
export const VERIFICATION_TYPE_ENUM_PROVE = 0;
export const VERIFICATION_TYPE_ENUM_DSC = 1;

0
common/src/utils/unitTest/generateMockProof.ts → common/src/utils/test/generateMockProof.ts
View File

1
contracts/contracts/OneTimeSBT.sol
View File

@@ -15,6 +15,7 @@ contract OneTimeSBT is ERC721Enumerable {
using Strings for uint256;
using Base64 for *;
//TODO: add ownable and functions to update verifiersmanager
IVerifiersManager public verifiersManager;
Formatter public formatter;

2
contracts/contracts/verifiers/VerifiersManager.sol
View File

@@ -11,6 +11,7 @@ contract VerifiersManager is IVerifiersManager, Ownable {
Dsc
}
// TODO: Key of these mappings are keccak256 hash of parameters in each signature algorithm
mapping(uint256 => address) public prove_verifiers;
mapping(uint256 => address) public dsc_verifiers;
@@ -46,6 +47,7 @@ contract VerifiersManager is IVerifiersManager, Ownable {
return result;
}
// TODO: add batch update function
function updateVerifier(
VerificationType v_type,
uint256 verifier_id,

1
contracts/package.json
View File

@@ -2,6 +2,7 @@
"name": "hardhat-project",
"scripts": {
"test": "npx hardhat test",
"test:local": "TEST_ENV=local npx hardhat test",
"deploy_all": "npx hardhat ignition deploy ignition/modules/Deploy_All.ts --network optimism --verify",
"compile": "npx hardhat compile"
},

970
contracts/test/RegisterAndDisclose.ts
View File

@@ -1,485 +1,485 @@
// import { expect, assert } from "chai";
// import { ethers } from "hardhat";
// // import { describe } from "mocha";
// import { mockPassportData_sha256_rsa_65537, mockPassportData_sha1_rsa_65537, } from "../../common/src/constants/mockPassportData";
// import { countryCodes, PASSPORT_ATTESTATION_ID, SignatureAlgorithmIndex } from "../../common/src/constants/constants";
// import { formatRoot } from "../../common/src/utils/utils";
// import { groth16 } from 'snarkjs'
// import { time } from "@nomicfoundation/hardhat-toolbox/network-helpers";
// import { generateCircuitInputsRegister, generateCircuitInputsDisclose } from "../../common/src/utils/generateInputs";
// import { formatCallData_disclose, formatCallData_dsc, formatCallData_register } from "../../common/src/utils/formatCallData";
// import fs from 'fs';
// import { LeanIMT } from "@zk-kit/lean-imt";
// import { poseidon2 } from "poseidon-lite";
// import { Signer } from "ethers";
// import { getCSCAInputs, getCSCAModulusMerkleTree } from "../../common/src/utils/csca";
// import forge from "node-forge";
// import { mock_csca_sha256_rsa_4096, mock_dsc_sha256_rsa_4096, mock_dsc_sha1_rsa_4096, mock_csca_sha1_rsa_4096 } from '../../common/src/constants/mockCertificates';
// type CircuitArtifacts = {
// [key: string]: {
// wasm: string,
// zkey: string,
// vkey: string,
// verifier?: any,
// inputs?: any,
// parsedCallData?: any,
// formattedCallData?: any
// }
// }
// describe("OpenPassport - Contracts - Register & Disclose flow", function () {
// this.timeout(0);
// let proof, publicSignals;
// let proof_dsc
// const register_circuits: CircuitArtifacts = {
// sha256WithRSAEncryption_65537: {
// wasm: "../circuits/build/register_sha256WithRSAEncryption_65537_js/register_sha256WithRSAEncryption_65537.wasm",
// zkey: "../circuits/build/register_sha256WithRSAEncryption_65537_final.zkey",
// vkey: "../circuits/build/register_sha256WithRSAEncryption_65537_vkey.json"
// },
// sha1WithRSAEncryption_65537: {
// wasm: "../circuits/build/register_sha1WithRSAEncryption_65537_js/register_sha1WithRSAEncryption_65537.wasm",
// zkey: "../circuits/build/register_sha1WithRSAEncryption_65537_final.zkey",
// vkey: "../circuits/build/register_sha1WithRSAEncryption_65537_vkey.json"
// },
// // sha256WithRSASSAPSS_65537: {
// // wasm: "../circuits/build/register_sha256WithRSASSAPSS_65537_js/register_sha256WithRSASSAPSS_65537.wasm",
// // zkey: "../circuits/build/register_sha256WithRSASSAPSS_65537_final.zkey",
// // vkey: "../circuits/build/register_sha256WithRSASSAPSS_65537_vkey.json"
// // }
// }
// const dsc_circuits: CircuitArtifacts = {
// sha256WithRSAEncryption_65537: {
// wasm: "../circuits/build/dsc_sha256_rsa_4096_js/dsc_sha256_rsa_4096.wasm",
// zkey: "../circuits/build/dsc_sha256_rsa_4096_final.zkey",
// vkey: "../circuits/build/dsc_sha256_rsa_4096_vkey.json"
// },
// sha1WithRSAEncryption_65537: {
// wasm: "../circuits/build/dsc_sha1_rsa_4096_js/dsc_sha1_rsa_4096.wasm",
// zkey: "../circuits/build/dsc_sha1_rsa_4096_final.zkey",
// vkey: "../circuits/build/dsc_sha1_rsa_4096_vkey.json"
// }
// }
// const path_disclose_wasm = "../circuits/build/disclose_js/disclose.wasm";
// const path_disclose_zkey = "../circuits/build/disclose_final.zkey";
// const path_disclose_vkey = "../circuits/build/disclose_vkey.json";
// const n_dsc = 121;
// const k_dsc = 17;
// const n_csca = 121;
// const k_csca = 34;
// const max_cert_bytes = 1664;
// const dscCert_sha256 = forge.pki.certificateFromPem(mock_dsc_sha256_rsa_4096);
// const cscaCert_sha256 = forge.pki.certificateFromPem(mock_csca_sha256_rsa_4096);
// const dscCert_sha1 = forge.pki.certificateFromPem(mock_dsc_sha1_rsa_4096);
// const cscaCert_sha1 = forge.pki.certificateFromPem(mock_csca_sha1_rsa_4096);
// let user_identifier, current_date;
// let registry: any, formatter: any, register: any, verifier_disclose: any, sbt: any, poseidonT3: any
// let owner, otherAccount, thirdAccount: Signer;
// let imt: LeanIMT;
// let selector_dg1, scope, user_address, majority, input_disclose: any;
// let proof_disclose, publicSignals_disclose, proof_result_disclose, vkey_disclose, verified_disclose: any, rawCallData_disclose, parsedCallData_disclose: any[], formattedCallData_disclose: any;
// //let proof_csca, publicSignals_csca: any;
// let secret: string = BigInt(0).toString();
// let attestation_id: string = PASSPORT_ATTESTATION_ID;
// before(
// async function generateProof() {
// [owner, otherAccount, thirdAccount] = await ethers.getSigners() as any[];
// // Set the next block timestamp to the current computer's timestamp
// const currentTimestamp = Math.floor(Date.now() / 1000) + 10;
// await ethers.provider.send('evm_setNextBlockTimestamp', [currentTimestamp]);
// await ethers.provider.send('evm_mine', []); // Mine a new block for the timestamp to take effect
// register_circuits.sha256WithRSAEncryption_65537.inputs = generateCircuitInputsRegister(
// secret,
// secret,
// attestation_id,
// mockPassportData_sha256_rsa_65537,
// n_dsc,
// k_dsc
// );
// register_circuits.sha1WithRSAEncryption_65537.inputs = generateCircuitInputsRegister(
// secret,
// secret,
// attestation_id,
// mockPassportData_sha1_rsa_65537,
// n_dsc,
// k_dsc
// );
// dsc_circuits.sha256WithRSAEncryption_65537.inputs = getCSCAInputs(BigInt(0).toString(), dscCert_sha256, cscaCert_sha256, n_dsc, k_dsc, n_csca, k_csca, max_cert_bytes, true);
// dsc_circuits.sha1WithRSAEncryption_65537.inputs = getCSCAInputs(BigInt(0).toString(), dscCert_sha1, cscaCert_sha1, n_dsc, k_dsc, n_csca, k_csca, max_cert_bytes, true);
// // register_circuits.sha256WithRSASSAPSS_65537.inputs = generateCircuitInputsRegister(
// // secret,
// // attestation_id,
// // mockPassportData_sha256WithRSASSAPSS_65537,
// // );
// //console.log("inputs", register_circuits.sha256WithRSAEncryption_65537.inputs);
// /*** Deploy contracts ***/
// await deployContracts();
// /*** Initialize merkle tree ***/
// imt = new LeanIMT((a: bigint, b: bigint) => poseidon2([a, b]), []);
// }
// );
// async function deployContracts(network = 'hardhat') {
// console.log(`Deploying contracts on ${network}...`);
// // Network-specific configurations can be added here
// let deployOptions = {};
// if (network !== 'hardhat') {
// deployOptions = {
// gasPrice: 10 * 10 ** 9,
// gasLimit: 8000000 // example gas limit
// };
// }
// const Verifier_dsc_sha256_rsa_4096 = await ethers.getContractFactory("Verifier_dsc_sha256_rsa_4096");
// const verifier_dsc_sha256_rsa_4096 = await Verifier_dsc_sha256_rsa_4096.deploy();
// await verifier_dsc_sha256_rsa_4096.waitForDeployment();
// dsc_circuits.sha256WithRSAEncryption_65537.verifier = verifier_dsc_sha256_rsa_4096;
// console.log('\x1b[34m%s\x1b[0m', `Verifier_dsc_sha256_rsa_4096 deployed to ${verifier_dsc_sha256_rsa_4096.target}`);
// const Verifier_dsc_sha1_rsa_4096 = await ethers.getContractFactory("Verifier_dsc_sha1_rsa_4096");
// const verifier_dsc_sha1_rsa_4096 = await Verifier_dsc_sha1_rsa_4096.deploy();
// await verifier_dsc_sha1_rsa_4096.waitForDeployment();
// dsc_circuits.sha1WithRSAEncryption_65537.verifier = verifier_dsc_sha1_rsa_4096;
// console.log('\x1b[34m%s\x1b[0m', `Verifier_dsc_sha1_rsa_4096 deployed to ${verifier_dsc_sha1_rsa_4096.target}`);
// const Verifier_register_sha256WithRSAEncryption_65537 = await ethers.getContractFactory("Verifier_register_sha256WithRSAEncryption_65537");
// const verifier_register_sha256WithRSAEncryption_65537 = await Verifier_register_sha256WithRSAEncryption_65537.deploy(deployOptions);
// await verifier_register_sha256WithRSAEncryption_65537.waitForDeployment();
// register_circuits.sha256WithRSAEncryption_65537.verifier = verifier_register_sha256WithRSAEncryption_65537;
// console.log('\x1b[34m%s\x1b[0m', `Verifier_register_sha256WithRSAEncryption_65537 deployed to ${verifier_register_sha256WithRSAEncryption_65537.target}`);
// const Verifier_register_sha1WithRSAEncryption_65537 = await ethers.getContractFactory("Verifier_register_sha1WithRSAEncryption_65537");
// const verifier_register_sha1WithRSAEncryption_65537 = await Verifier_register_sha1WithRSAEncryption_65537.deploy(deployOptions);
// await verifier_register_sha1WithRSAEncryption_65537.waitForDeployment();
// register_circuits.sha1WithRSAEncryption_65537.verifier = verifier_register_sha1WithRSAEncryption_65537;
// console.log('\x1b[34m%s\x1b[0m', `Verifier_register_sha1WithRSAEncryption_65537 deployed to ${verifier_register_sha1WithRSAEncryption_65537.target}`);
// // const Verifier_register_sha256WithRSASSAPSS_65537 = await ethers.getContractFactory("Verifier_register_sha256WithRSASSAPSS_65537");
// // const verifier_register_sha256WithRSASSAPSS_65537 = await Verifier_register_sha256WithRSASSAPSS_65537.deploy(deployOptions);
// // await verifier_register_sha256WithRSASSAPSS_65537.waitForDeployment();
// // register_circuits.sha256WithRSASSAPSS_65537.verifier = verifier_register_sha256WithRSASSAPSS_65537;
// // console.log('\x1b[34m%s\x1b[0m', `Verifier_register_sha256WithRSASSAPSS_65537 deployed to ${verifier_register_sha256WithRSASSAPSS_65537.target}`);
// const Formatter = await ethers.getContractFactory("Formatter");
// formatter = await Formatter.deploy(deployOptions);
// await formatter.waitForDeployment();
// await formatter.addCountryCodes(Object.entries(countryCodes));
// console.log('\x1b[34m%s\x1b[0m', `Formatter deployed to ${formatter.target}`);
// const Registry = await ethers.getContractFactory("Registry");
// const merkleTree = getCSCAModulusMerkleTree();
// registry = await Registry.deploy(formatRoot(merkleTree.root), deployOptions);
// await registry.waitForDeployment();
// console.log('\x1b[34m%s\x1b[0m', `Registry deployed to ${registry.target}`);
// const PoseidonT3 = await ethers.getContractFactory("PoseidonT3");
// poseidonT3 = await PoseidonT3.deploy(deployOptions);
// await poseidonT3.waitForDeployment();
// console.log('\x1b[34m%s\x1b[0m', `PoseidonT3 deployed to: ${poseidonT3.target}`);
// const poseidonT3Address = poseidonT3.target;
// const Register = await ethers.getContractFactory("OpenPassportRegister", {
// libraries: {
// PoseidonT3: poseidonT3Address
// }
// });
// register = await Register.deploy(registry.target, deployOptions);
// await register.waitForDeployment();
// console.log('\x1b[34m%s\x1b[0m', `Register deployed to ${register.target}`);
// // console.log("register merkle root:", await registry.getMerkleRoot());
// const Verifier_disclose = await ethers.getContractFactory("Verifier_disclose");
// verifier_disclose = await Verifier_disclose.deploy(deployOptions);
// await verifier_disclose.waitForDeployment();
// console.log('\x1b[34m%s\x1b[0m', `Verifier_disclose deployed to ${verifier_disclose.target}`);
// await register.addSignatureAlgorithm(SignatureAlgorithmIndex.rsa_sha256, verifier_register_sha256WithRSAEncryption_65537.target);
// await register.addCSCAVerifier(SignatureAlgorithmIndex.rsa_sha256, verifier_dsc_sha256_rsa_4096.target);
// await register.addSignatureAlgorithm(SignatureAlgorithmIndex.rsa_sha1, verifier_register_sha1WithRSAEncryption_65537.target);
// await register.addCSCAVerifier(SignatureAlgorithmIndex.rsa_sha1, verifier_dsc_sha1_rsa_4096.target);
// const SBT = await ethers.getContractFactory("SBT");
// sbt = await SBT.deploy(
// verifier_disclose.target,
// formatter.target,
// register.target,
// deployOptions
// );
// await sbt.waitForDeployment();
// console.log('\x1b[34m%s\x1b[0m', `SBT deployed to ${sbt.target}`);
// }
// describe("OpenPassport - Utils flow", function () {
// it("Should convert ISO dates to unix timestamps correctly", async function () {
// const unix_timestamp = await formatter.dateToUnixTimestamp("230512") // 2023 05 12
// console.log('unix_timestamp', unix_timestamp.toString());
// var date = new Date(Number(unix_timestamp) * 1000);
// console.log("date:", date.toUTCString());
// expect(date.getUTCFullYear()).to.equal(2023);
// expect(date.getUTCMonth()).to.equal(4);
// expect(date.getUTCDate()).to.equal(12);
// })
// })
// /*** Register flow ***/
// describe("OpenPassport - Register flow", function () {
// const sigAlgNames = ['sha256WithRSAEncryption_65537', 'sha1WithRSAEncryption_65537'] //, 'sha1WithRSAEncryption_65537', 'sha256WithRSASSAPSS_65537']
// before(async function () {
// await Promise.all(sigAlgNames.map(async (sigAlgName) => {
// const sigAlgArtifacts_register = register_circuits[sigAlgName];
// /*** Groth16 saga Register***/
// // Generate the proofs
// console.log('\x1b[32m%s\x1b[0m', `Generating proof csca - ${sigAlgName}`);
// //console.log("csc_modulus_length", inputs_csca.inputs.csca_modulus.length);
// const proof_csca_result = await groth16.fullProve(
// dsc_circuits[sigAlgName].inputs.inputs,
// dsc_circuits[sigAlgName].wasm,
// dsc_circuits[sigAlgName].zkey
// )
// const proof_csca = proof_csca_result.proof;
// const publicSignals_csca = proof_csca_result.publicSignals;
// console.log('\x1b[32m%s\x1b[0m', `Proof generated csca - ${sigAlgName}`);
// // console.log("proof_csca", proof_csca);
// // console.log("publicSignals_csca", publicSignals_csca);
// const vKey_csca = JSON.parse(fs.readFileSync(dsc_circuits[sigAlgName].vkey) as unknown as string);
// const verified_csca = await groth16.verify(
// vKey_csca,
// publicSignals_csca,
// proof_csca
// )
// assert(verified_csca == true, 'Should verify')
// console.log('\x1b[32m%s\x1b[0m', `Proof verified csca - ${sigAlgName}`);
// const rawCallData_csca = await groth16.exportSolidityCallData(proof_csca, publicSignals_csca);
// dsc_circuits[sigAlgName].parsedCallData = JSON.parse(`[${rawCallData_csca}]`);
// dsc_circuits[sigAlgName].formattedCallData = formatCallData_dsc(dsc_circuits[sigAlgName].parsedCallData);
// //console.log('inputs', sigAlgArtifacts_register.inputs);
// console.log('\x1b[32m%s\x1b[0m', `Generating proof register - ${sigAlgName}`);
// ({ proof, publicSignals } = await groth16.fullProve(
// sigAlgArtifacts_register.inputs,
// sigAlgArtifacts_register.wasm,
// sigAlgArtifacts_register.zkey
// ))
// console.log('\x1b[32m%s\x1b[0m', `Proof generated register - ${sigAlgName}`);
// // Verify the proof
// const vKey = JSON.parse(fs.readFileSync(sigAlgArtifacts_register.vkey) as unknown as string);
// const verified = await groth16.verify(
// vKey,
// publicSignals,
// proof
// )
// assert(verified == true, 'Should verify')
// console.log('\x1b[32m%s\x1b[0m', `Proof verified - ${sigAlgName}`);
// const rawCallData = await groth16.exportSolidityCallData(proof, publicSignals);
// const parsedCallData = JSON.parse(`[${rawCallData}]`);
// register_circuits[sigAlgName].parsedCallData = parsedCallData
// register_circuits[sigAlgName].formattedCallData = formatCallData_register(parsedCallData)
// // Set fake commitments into the tree
// const commitments = Array.from(new Set(Array.from({ length: 3 }, () => Math.floor(Math.random() * 100000000))));
// for (const commitment of commitments) {
// await register.devAddCommitment(commitment); // this is a dev function and will not be deployed in production
// imt.insert(BigInt(commitment));
// }
// }));
// });
// for (const sigAlgName of sigAlgNames) {
// const sigAlgArtifacts_register = register_circuits[sigAlgName];
// const sigAlgArtifacts_dsc = dsc_circuits[sigAlgName];
// const sigAlgIndex = SignatureAlgorithmIndex[sigAlgName as keyof typeof SignatureAlgorithmIndex]
// it(`Verifier contract verifies a correct proof - Register - ${sigAlgName}`, async function () {
// expect(
// await sigAlgArtifacts_register.verifier.verifyProof(
// sigAlgArtifacts_register.parsedCallData[0],
// sigAlgArtifacts_register.parsedCallData[1],
// sigAlgArtifacts_register.parsedCallData[2],
// sigAlgArtifacts_register.parsedCallData[3]
// )
// ).to.be.true;
// });
// it(`Verifier contract verifies a correct proof - DSC - ${sigAlgName}`, async function () {
// expect(
// await sigAlgArtifacts_dsc.verifier.verifyProof(
// sigAlgArtifacts_dsc.parsedCallData[0],
// sigAlgArtifacts_dsc.parsedCallData[1],
// sigAlgArtifacts_dsc.parsedCallData[2],
// sigAlgArtifacts_dsc.parsedCallData[3]
// )
// ).to.be.true;
// });
// it(`Register with a wrong proof should fail - Register - ${sigAlgName}`, async function () {
// await expect(register
// .validateProof({ ...sigAlgArtifacts_register.formattedCallData, a: [0, 0] }, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex, sigAlgIndex))
// .to.be.revertedWith("Register__InvalidProofRegister");
// });
// it(`Register with a wrong attestation id should fail - Register - ${sigAlgName}`, async function () {
// await expect(register
// .validateProof({ ...sigAlgArtifacts_register.formattedCallData, attestation_id: "10" }, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex, sigAlgIndex))
// .to.be.revertedWith("Register__InvalidAttestationId")
// });
// it(`Register with a wrong signature algorithm should fail - Register - ${sigAlgName}`, async function () {
// await expect(register
// .validateProof({ ...sigAlgArtifacts_register.formattedCallData }, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex + 1, sigAlgIndex))
// .to.be.revertedWith("Register__InvalidSignatureAlgorithm()")
// .catch(error => {
// assert(error.message.includes("Register__InvalidSignatureAlgorithm()"), "Expected revert with Register__InvalidSignatureAlgorithm(), but got another error");
// });
// });
// it(`Register with a wrong merkle root should fail - Register - ${sigAlgName}`, async function () {
// await expect(register
// .validateProof(sigAlgArtifacts_register.formattedCallData, { ...sigAlgArtifacts_dsc.formattedCallData, merkle_root: 0 }, sigAlgIndex, sigAlgIndex))
// .to.be.revertedWith("Register__InvalidMerkleRoot")
// });
// it(`Register should succeed - Register - ${sigAlgName}`, async function () {
// await expect(register
// .validateProof(sigAlgArtifacts_register.formattedCallData, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex, sigAlgIndex)).not.to.be.reverted;
// imt.insert(BigInt(sigAlgArtifacts_register.formattedCallData.commitment));
// /// check if the merkle root is equal to the one from the imt
// // console.log('\x1b[34m%s\x1b[0m', `IMT Merkle root of TS Object - TS: ${imt.root}`);
// // console.log('\x1b[34m%s\x1b[0m', `Merkle root of contract - TSx: ${await register.getMerkleRoot()}`);
// assert.equal(await register.getMerkleRoot(), imt.root);
// console.log('\x1b[34m%s\x1b[0m', `Merkle roots from TS Object and Smart Contract are equal: ${imt.root}`);
// });
// // it(`Register with the same proof should fail - Register - ${sigAlgName}`, async function () {
// // await expect(register
// // .validateProof(sigAlgArtifacts_register.formattedCallData, sigAlgIndex))
// // .to.be.revertedWith("Register__YouAreUsingTheSameNullifierTwice()")
// // .catch(error => {
// // assert(error.message.includes("Register__YouAreUsingTheSameNullifierTwice()"), "Expected revert with Register__YouAreUsingTheSameNullifierTwice(), but got another error");
// // });
// // });
// };
// });
// /*** Disclose flow ***/
// // describe("OpenPassport - Disclose flow", function () {
// // this.beforeAll(async function () {
// // user_address = await thirdAccount.getAddress();
// // // We only test with the sha256WithRSAEncryption_65537 commitment for now
// // // refactor in generate inputs function
// // selector_dg1 = Array(90).fill("1");
// // scope = BigInt(1).toString();
// // majority = ["1", "8"];
// // input_disclose = generateCircuitInputsDisclose(
// // register_circuits.sha256WithRSAEncryption_65537.inputs.secret,
// // register_circuits.sha256WithRSAEncryption_65537.inputs.attestation_id,
// // mockPassportData_sha256_rsa_65537,
// // imt as any,
// // majority,
// // selector_dg1,
// // scope,
// // BigInt(user_address.toString()).toString()
// // );
// // // Generate the proof
// // console.log('\x1b[32m%s\x1b[0m', 'Generating proof - Disclose');
// // try {
// // proof_result_disclose = await groth16.fullProve(
// // input_disclose,
// // path_disclose_wasm,
// // path_disclose_zkey
// // );
// // } catch (error) {
// // console.error("Error generating proof:", error);
// // throw error;
// // }
// // proof_disclose = proof_result_disclose.proof;
// // publicSignals_disclose = proof_result_disclose.publicSignals;
// // console.log('\x1b[32m%s\x1b[0m', 'Proof generated - Disclose');
// // // Verify the proof
// // vkey_disclose = JSON.parse(fs.readFileSync(path_disclose_vkey) as unknown as string);
// // verified_disclose = await groth16.verify(
// // vkey_disclose,
// // publicSignals_disclose,
// // proof_disclose
// // )
// // console.log('\x1b[32m%s\x1b[0m', 'Proof verified - Disclose');
// // rawCallData_disclose = await groth16.exportSolidityCallData(proof_disclose, publicSignals_disclose);
// // parsedCallData_disclose = JSON.parse(`[${rawCallData_disclose}]`);
// // formattedCallData_disclose = formatCallData_disclose(parsedCallData_disclose);
// // // console.log('formattedCallData_disclose', formattedCallData_disclose);
// // })
// // it("SBT mint should succeed - SBT", async function () {
// // await expect(sbt.mint(formattedCallData_disclose))
// // .to.not.be.reverted;
// // });
// // // // refactor in generate inputs function
// // // selector_dg1 = Array(90).fill("1");
// // // scope = BigInt(1).toString();
// // // user_address = await thirdAccount.getAddress();
// // // majority = ["1", "8"];
// // // input_disclose = generateCircuitInputsDisclose(
// // // inputs.secret,
// // // inputs.attestation_id,
// // // passportData,
// // // imt as any,
// // // majority,
// // // selector_dg1,
// // // scope,
// // // BigInt(user_address.toString()).toString()
// // // );
// // // // Generate the proof
// // // console.log('\x1b[32m%s\x1b[0m', 'Generating proof - Disclose');
// // // try {
// // // proof_result_disclose = await groth16.fullProve(
// // // input_disclose,
// // // path_disclose_wasm,
// // // path_disclose_zkey
// // // );
// // // } catch (error) {
// // // console.error("Error generating proof:", error);
// // // throw error;
// // // }
// // // proof_disclose = proof_result_disclose.proof;
// // // publicSignals_disclose = proof_result_disclose.publicSignals;
// // // assert(verified_disclose == true, 'Should verify')
// // });
// })
import { expect, assert } from "chai";
import { ethers } from "hardhat";
// import { describe } from "mocha";
import { mockPassportData_sha256_rsa_65537, mockPassportData_sha1_rsa_65537, } from "../../common/src/constants/mockPassportData";
import { countryCodes, PASSPORT_ATTESTATION_ID, SignatureAlgorithmIndex } from "../../common/src/constants/constants";
import { formatRoot } from "../../common/src/utils/utils";
import { groth16 } from 'snarkjs'
import { time } from "@nomicfoundation/hardhat-toolbox/network-helpers";
import { generateCircuitInputsRegister, generateCircuitInputsDisclose } from "../../common/src/utils/generateInputs";
import { formatCallData_disclose, formatCallData_dsc, formatCallData_register } from "../../common/src/utils/formatCallData";
import fs from 'fs';
import { LeanIMT } from "@zk-kit/lean-imt";
import { poseidon2 } from "poseidon-lite";
import { Signer } from "ethers";
import { getCSCAInputs, getCSCAModulusMerkleTree } from "../../common/src/utils/csca";
import forge from "node-forge";
import { mock_csca_sha256_rsa_4096, mock_dsc_sha256_rsa_4096, mock_dsc_sha1_rsa_4096, mock_csca_sha1_rsa_4096 } from '../../common/src/constants/mockCertificates';
type CircuitArtifacts = {
[key: string]: {
wasm: string,
zkey: string,
vkey: string,
verifier?: any,
inputs?: any,
parsedCallData?: any,
formattedCallData?: any
}
}
describe("OpenPassport - Contracts - Register & Disclose flow", function () {
this.timeout(0);
let proof, publicSignals;
let proof_dsc
const register_circuits: CircuitArtifacts = {
sha256WithRSAEncryption_65537: {
wasm: "../circuits/build/register_sha256WithRSAEncryption_65537_js/register_sha256WithRSAEncryption_65537.wasm",
zkey: "../circuits/build/register_sha256WithRSAEncryption_65537_final.zkey",
vkey: "../circuits/build/register_sha256WithRSAEncryption_65537_vkey.json"
},
sha1WithRSAEncryption_65537: {
wasm: "../circuits/build/register_sha1WithRSAEncryption_65537_js/register_sha1WithRSAEncryption_65537.wasm",
zkey: "../circuits/build/register_sha1WithRSAEncryption_65537_final.zkey",
vkey: "../circuits/build/register_sha1WithRSAEncryption_65537_vkey.json"
},
// sha256WithRSASSAPSS_65537: {
// wasm: "../circuits/build/register_sha256WithRSASSAPSS_65537_js/register_sha256WithRSASSAPSS_65537.wasm",
// zkey: "../circuits/build/register_sha256WithRSASSAPSS_65537_final.zkey",
// vkey: "../circuits/build/register_sha256WithRSASSAPSS_65537_vkey.json"
// }
}
const dsc_circuits: CircuitArtifacts = {
sha256WithRSAEncryption_65537: {
wasm: "../circuits/build/dsc_sha256_rsa_4096_js/dsc_sha256_rsa_4096.wasm",
zkey: "../circuits/build/dsc_sha256_rsa_4096_final.zkey",
vkey: "../circuits/build/dsc_sha256_rsa_4096_vkey.json"
},
sha1WithRSAEncryption_65537: {
wasm: "../circuits/build/dsc_sha1_rsa_4096_js/dsc_sha1_rsa_4096.wasm",
zkey: "../circuits/build/dsc_sha1_rsa_4096_final.zkey",
vkey: "../circuits/build/dsc_sha1_rsa_4096_vkey.json"
}
}
const path_disclose_wasm = "../circuits/build/disclose_js/disclose.wasm";
const path_disclose_zkey = "../circuits/build/disclose_final.zkey";
const path_disclose_vkey = "../circuits/build/disclose_vkey.json";
const n_dsc = 121;
const k_dsc = 17;
const n_csca = 121;
const k_csca = 34;
const max_cert_bytes = 1664;
const dscCert_sha256 = forge.pki.certificateFromPem(mock_dsc_sha256_rsa_4096);
const cscaCert_sha256 = forge.pki.certificateFromPem(mock_csca_sha256_rsa_4096);
const dscCert_sha1 = forge.pki.certificateFromPem(mock_dsc_sha1_rsa_4096);
const cscaCert_sha1 = forge.pki.certificateFromPem(mock_csca_sha1_rsa_4096);
let user_identifier, current_date;
let registry: any, formatter: any, register: any, verifier_disclose: any, sbt: any, poseidonT3: any
let owner, otherAccount, thirdAccount: Signer;
let imt: LeanIMT;
let selector_dg1, scope, user_address, majority, input_disclose: any;
let proof_disclose, publicSignals_disclose, proof_result_disclose, vkey_disclose, verified_disclose: any, rawCallData_disclose, parsedCallData_disclose: any[], formattedCallData_disclose: any;
//let proof_csca, publicSignals_csca: any;
let secret: string = BigInt(0).toString();
let attestation_id: string = PASSPORT_ATTESTATION_ID;
before(
async function generateProof() {
[owner, otherAccount, thirdAccount] = await ethers.getSigners() as any[];
// Set the next block timestamp to the current computer's timestamp
const currentTimestamp = Math.floor(Date.now() / 1000) + 10;
await ethers.provider.send('evm_setNextBlockTimestamp', [currentTimestamp]);
await ethers.provider.send('evm_mine', []); // Mine a new block for the timestamp to take effect
register_circuits.sha256WithRSAEncryption_65537.inputs = generateCircuitInputsRegister(
secret,
secret,
attestation_id,
mockPassportData_sha256_rsa_65537,
n_dsc,
k_dsc
);
register_circuits.sha1WithRSAEncryption_65537.inputs = generateCircuitInputsRegister(
secret,
secret,
attestation_id,
mockPassportData_sha1_rsa_65537,
n_dsc,
k_dsc
);
dsc_circuits.sha256WithRSAEncryption_65537.inputs = getCSCAInputs(BigInt(0).toString(), dscCert_sha256, cscaCert_sha256, n_dsc, k_dsc, n_csca, k_csca, max_cert_bytes, true);
dsc_circuits.sha1WithRSAEncryption_65537.inputs = getCSCAInputs(BigInt(0).toString(), dscCert_sha1, cscaCert_sha1, n_dsc, k_dsc, n_csca, k_csca, max_cert_bytes, true);
// register_circuits.sha256WithRSASSAPSS_65537.inputs = generateCircuitInputsRegister(
// secret,
// attestation_id,
// mockPassportData_sha256WithRSASSAPSS_65537,
// );
//console.log("inputs", register_circuits.sha256WithRSAEncryption_65537.inputs);
/*** Deploy contracts ***/
await deployContracts();
/*** Initialize merkle tree ***/
imt = new LeanIMT((a: bigint, b: bigint) => poseidon2([a, b]), []);
}
);
async function deployContracts(network = 'hardhat') {
console.log(`Deploying contracts on ${network}...`);
// Network-specific configurations can be added here
let deployOptions = {};
if (network !== 'hardhat') {
deployOptions = {
gasPrice: 10 * 10 ** 9,
gasLimit: 8000000 // example gas limit
};
}
const Verifier_dsc_sha256_rsa_4096 = await ethers.getContractFactory("Verifier_dsc_sha256_rsa_4096");
const verifier_dsc_sha256_rsa_4096 = await Verifier_dsc_sha256_rsa_4096.deploy();
await verifier_dsc_sha256_rsa_4096.waitForDeployment();
dsc_circuits.sha256WithRSAEncryption_65537.verifier = verifier_dsc_sha256_rsa_4096;
console.log('\x1b[34m%s\x1b[0m', `Verifier_dsc_sha256_rsa_4096 deployed to ${verifier_dsc_sha256_rsa_4096.target}`);
const Verifier_dsc_sha1_rsa_4096 = await ethers.getContractFactory("Verifier_dsc_sha1_rsa_4096");
const verifier_dsc_sha1_rsa_4096 = await Verifier_dsc_sha1_rsa_4096.deploy();
await verifier_dsc_sha1_rsa_4096.waitForDeployment();
dsc_circuits.sha1WithRSAEncryption_65537.verifier = verifier_dsc_sha1_rsa_4096;
console.log('\x1b[34m%s\x1b[0m', `Verifier_dsc_sha1_rsa_4096 deployed to ${verifier_dsc_sha1_rsa_4096.target}`);
const Verifier_register_sha256WithRSAEncryption_65537 = await ethers.getContractFactory("Verifier_register_sha256WithRSAEncryption_65537");
const verifier_register_sha256WithRSAEncryption_65537 = await Verifier_register_sha256WithRSAEncryption_65537.deploy(deployOptions);
await verifier_register_sha256WithRSAEncryption_65537.waitForDeployment();
register_circuits.sha256WithRSAEncryption_65537.verifier = verifier_register_sha256WithRSAEncryption_65537;
console.log('\x1b[34m%s\x1b[0m', `Verifier_register_sha256WithRSAEncryption_65537 deployed to ${verifier_register_sha256WithRSAEncryption_65537.target}`);
const Verifier_register_sha1WithRSAEncryption_65537 = await ethers.getContractFactory("Verifier_register_sha1WithRSAEncryption_65537");
const verifier_register_sha1WithRSAEncryption_65537 = await Verifier_register_sha1WithRSAEncryption_65537.deploy(deployOptions);
await verifier_register_sha1WithRSAEncryption_65537.waitForDeployment();
register_circuits.sha1WithRSAEncryption_65537.verifier = verifier_register_sha1WithRSAEncryption_65537;
console.log('\x1b[34m%s\x1b[0m', `Verifier_register_sha1WithRSAEncryption_65537 deployed to ${verifier_register_sha1WithRSAEncryption_65537.target}`);
// const Verifier_register_sha256WithRSASSAPSS_65537 = await ethers.getContractFactory("Verifier_register_sha256WithRSASSAPSS_65537");
// const verifier_register_sha256WithRSASSAPSS_65537 = await Verifier_register_sha256WithRSASSAPSS_65537.deploy(deployOptions);
// await verifier_register_sha256WithRSASSAPSS_65537.waitForDeployment();
// register_circuits.sha256WithRSASSAPSS_65537.verifier = verifier_register_sha256WithRSASSAPSS_65537;
// console.log('\x1b[34m%s\x1b[0m', `Verifier_register_sha256WithRSASSAPSS_65537 deployed to ${verifier_register_sha256WithRSASSAPSS_65537.target}`);
const Formatter = await ethers.getContractFactory("Formatter");
formatter = await Formatter.deploy(deployOptions);
await formatter.waitForDeployment();
await formatter.addCountryCodes(Object.entries(countryCodes));
console.log('\x1b[34m%s\x1b[0m', `Formatter deployed to ${formatter.target}`);
const Registry = await ethers.getContractFactory("Registry");
const merkleTree = getCSCAModulusMerkleTree();
registry = await Registry.deploy(formatRoot(merkleTree.root), deployOptions);
await registry.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `Registry deployed to ${registry.target}`);
const PoseidonT3 = await ethers.getContractFactory("PoseidonT3");
poseidonT3 = await PoseidonT3.deploy(deployOptions);
await poseidonT3.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `PoseidonT3 deployed to: ${poseidonT3.target}`);
const poseidonT3Address = poseidonT3.target;
const Register = await ethers.getContractFactory("OpenPassportRegister", {
libraries: {
PoseidonT3: poseidonT3Address
}
});
register = await Register.deploy(registry.target, deployOptions);
await register.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `Register deployed to ${register.target}`);
// console.log("register merkle root:", await registry.getMerkleRoot());
const Verifier_disclose = await ethers.getContractFactory("Verifier_disclose");
verifier_disclose = await Verifier_disclose.deploy(deployOptions);
await verifier_disclose.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `Verifier_disclose deployed to ${verifier_disclose.target}`);
await register.addSignatureAlgorithm(SignatureAlgorithmIndex.rsa_sha256, verifier_register_sha256WithRSAEncryption_65537.target);
await register.addCSCAVerifier(SignatureAlgorithmIndex.rsa_sha256, verifier_dsc_sha256_rsa_4096.target);
await register.addSignatureAlgorithm(SignatureAlgorithmIndex.rsa_sha1, verifier_register_sha1WithRSAEncryption_65537.target);
await register.addCSCAVerifier(SignatureAlgorithmIndex.rsa_sha1, verifier_dsc_sha1_rsa_4096.target);
const SBT = await ethers.getContractFactory("SBT");
sbt = await SBT.deploy(
verifier_disclose.target,
formatter.target,
register.target,
deployOptions
);
await sbt.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `SBT deployed to ${sbt.target}`);
}
describe("OpenPassport - Utils flow", function () {
it("Should convert ISO dates to unix timestamps correctly", async function () {
const unix_timestamp = await formatter.dateToUnixTimestamp("230512") // 2023 05 12
console.log('unix_timestamp', unix_timestamp.toString());
var date = new Date(Number(unix_timestamp) * 1000);
console.log("date:", date.toUTCString());
expect(date.getUTCFullYear()).to.equal(2023);
expect(date.getUTCMonth()).to.equal(4);
expect(date.getUTCDate()).to.equal(12);
})
})
/*** Register flow ***/
describe("OpenPassport - Register flow", function () {
const sigAlgNames = ['sha256WithRSAEncryption_65537', 'sha1WithRSAEncryption_65537'] //, 'sha1WithRSAEncryption_65537', 'sha256WithRSASSAPSS_65537']
before(async function () {
await Promise.all(sigAlgNames.map(async (sigAlgName) => {
const sigAlgArtifacts_register = register_circuits[sigAlgName];
/*** Groth16 saga Register***/
// Generate the proofs
console.log('\x1b[32m%s\x1b[0m', `Generating proof csca - ${sigAlgName}`);
//console.log("csc_modulus_length", inputs_csca.inputs.csca_modulus.length);
const proof_csca_result = await groth16.fullProve(
dsc_circuits[sigAlgName].inputs.inputs,
dsc_circuits[sigAlgName].wasm,
dsc_circuits[sigAlgName].zkey
)
const proof_csca = proof_csca_result.proof;
const publicSignals_csca = proof_csca_result.publicSignals;
console.log('\x1b[32m%s\x1b[0m', `Proof generated csca - ${sigAlgName}`);
// console.log("proof_csca", proof_csca);
// console.log("publicSignals_csca", publicSignals_csca);
const vKey_csca = JSON.parse(fs.readFileSync(dsc_circuits[sigAlgName].vkey) as unknown as string);
const verified_csca = await groth16.verify(
vKey_csca,
publicSignals_csca,
proof_csca
)
assert(verified_csca == true, 'Should verify')
console.log('\x1b[32m%s\x1b[0m', `Proof verified csca - ${sigAlgName}`);
const rawCallData_csca = await groth16.exportSolidityCallData(proof_csca, publicSignals_csca);
dsc_circuits[sigAlgName].parsedCallData = JSON.parse(`[${rawCallData_csca}]`);
dsc_circuits[sigAlgName].formattedCallData = formatCallData_dsc(dsc_circuits[sigAlgName].parsedCallData);
//console.log('inputs', sigAlgArtifacts_register.inputs);
console.log('\x1b[32m%s\x1b[0m', `Generating proof register - ${sigAlgName}`);
({ proof, publicSignals } = await groth16.fullProve(
sigAlgArtifacts_register.inputs,
sigAlgArtifacts_register.wasm,
sigAlgArtifacts_register.zkey
))
console.log('\x1b[32m%s\x1b[0m', `Proof generated register - ${sigAlgName}`);
// Verify the proof
const vKey = JSON.parse(fs.readFileSync(sigAlgArtifacts_register.vkey) as unknown as string);
const verified = await groth16.verify(
vKey,
publicSignals,
proof
)
assert(verified == true, 'Should verify')
console.log('\x1b[32m%s\x1b[0m', `Proof verified - ${sigAlgName}`);
const rawCallData = await groth16.exportSolidityCallData(proof, publicSignals);
const parsedCallData = JSON.parse(`[${rawCallData}]`);
register_circuits[sigAlgName].parsedCallData = parsedCallData
register_circuits[sigAlgName].formattedCallData = formatCallData_register(parsedCallData)
// Set fake commitments into the tree
const commitments = Array.from(new Set(Array.from({ length: 3 }, () => Math.floor(Math.random() * 100000000))));
for (const commitment of commitments) {
await register.devAddCommitment(commitment); // this is a dev function and will not be deployed in production
imt.insert(BigInt(commitment));
}
}));
});
for (const sigAlgName of sigAlgNames) {
const sigAlgArtifacts_register = register_circuits[sigAlgName];
const sigAlgArtifacts_dsc = dsc_circuits[sigAlgName];
const sigAlgIndex = SignatureAlgorithmIndex[sigAlgName as keyof typeof SignatureAlgorithmIndex]
it(`Verifier contract verifies a correct proof - Register - ${sigAlgName}`, async function () {
expect(
await sigAlgArtifacts_register.verifier.verifyProof(
sigAlgArtifacts_register.parsedCallData[0],
sigAlgArtifacts_register.parsedCallData[1],
sigAlgArtifacts_register.parsedCallData[2],
sigAlgArtifacts_register.parsedCallData[3]
)
).to.be.true;
});
it(`Verifier contract verifies a correct proof - DSC - ${sigAlgName}`, async function () {
expect(
await sigAlgArtifacts_dsc.verifier.verifyProof(
sigAlgArtifacts_dsc.parsedCallData[0],
sigAlgArtifacts_dsc.parsedCallData[1],
sigAlgArtifacts_dsc.parsedCallData[2],
sigAlgArtifacts_dsc.parsedCallData[3]
)
).to.be.true;
});
it(`Register with a wrong proof should fail - Register - ${sigAlgName}`, async function () {
await expect(register
.validateProof({ ...sigAlgArtifacts_register.formattedCallData, a: [0, 0] }, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex, sigAlgIndex))
.to.be.revertedWith("Register__InvalidProofRegister");
});
it(`Register with a wrong attestation id should fail - Register - ${sigAlgName}`, async function () {
await expect(register
.validateProof({ ...sigAlgArtifacts_register.formattedCallData, attestation_id: "10" }, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex, sigAlgIndex))
.to.be.revertedWith("Register__InvalidAttestationId")
});
it(`Register with a wrong signature algorithm should fail - Register - ${sigAlgName}`, async function () {
await expect(register
.validateProof({ ...sigAlgArtifacts_register.formattedCallData }, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex + 1, sigAlgIndex))
.to.be.revertedWith("Register__InvalidSignatureAlgorithm()")
.catch(error => {
assert(error.message.includes("Register__InvalidSignatureAlgorithm()"), "Expected revert with Register__InvalidSignatureAlgorithm(), but got another error");
});
});
it(`Register with a wrong merkle root should fail - Register - ${sigAlgName}`, async function () {
await expect(register
.validateProof(sigAlgArtifacts_register.formattedCallData, { ...sigAlgArtifacts_dsc.formattedCallData, merkle_root: 0 }, sigAlgIndex, sigAlgIndex))
.to.be.revertedWith("Register__InvalidMerkleRoot")
});
it(`Register should succeed - Register - ${sigAlgName}`, async function () {
await expect(register
.validateProof(sigAlgArtifacts_register.formattedCallData, sigAlgArtifacts_dsc.formattedCallData, sigAlgIndex, sigAlgIndex)).not.to.be.reverted;
imt.insert(BigInt(sigAlgArtifacts_register.formattedCallData.commitment));
/// check if the merkle root is equal to the one from the imt
// console.log('\x1b[34m%s\x1b[0m', `IMT Merkle root of TS Object - TS: ${imt.root}`);
// console.log('\x1b[34m%s\x1b[0m', `Merkle root of contract - TSx: ${await register.getMerkleRoot()}`);
assert.equal(await register.getMerkleRoot(), imt.root);
console.log('\x1b[34m%s\x1b[0m', `Merkle roots from TS Object and Smart Contract are equal: ${imt.root}`);
});
// it(`Register with the same proof should fail - Register - ${sigAlgName}`, async function () {
// await expect(register
// .validateProof(sigAlgArtifacts_register.formattedCallData, sigAlgIndex))
// .to.be.revertedWith("Register__YouAreUsingTheSameNullifierTwice()")
// .catch(error => {
// assert(error.message.includes("Register__YouAreUsingTheSameNullifierTwice()"), "Expected revert with Register__YouAreUsingTheSameNullifierTwice(), but got another error");
// });
// });
};
});
/*** Disclose flow ***/
// describe("OpenPassport - Disclose flow", function () {
// this.beforeAll(async function () {
// user_address = await thirdAccount.getAddress();
// // We only test with the sha256WithRSAEncryption_65537 commitment for now
// // refactor in generate inputs function
// selector_dg1 = Array(90).fill("1");
// scope = BigInt(1).toString();
// majority = ["1", "8"];
// input_disclose = generateCircuitInputsDisclose(
// register_circuits.sha256WithRSAEncryption_65537.inputs.secret,
// register_circuits.sha256WithRSAEncryption_65537.inputs.attestation_id,
// mockPassportData_sha256_rsa_65537,
// imt as any,
// majority,
// selector_dg1,
// scope,
// BigInt(user_address.toString()).toString()
// );
// // Generate the proof
// console.log('\x1b[32m%s\x1b[0m', 'Generating proof - Disclose');
// try {
// proof_result_disclose = await groth16.fullProve(
// input_disclose,
// path_disclose_wasm,
// path_disclose_zkey
// );
// } catch (error) {
// console.error("Error generating proof:", error);
// throw error;
// }
// proof_disclose = proof_result_disclose.proof;
// publicSignals_disclose = proof_result_disclose.publicSignals;
// console.log('\x1b[32m%s\x1b[0m', 'Proof generated - Disclose');
// // Verify the proof
// vkey_disclose = JSON.parse(fs.readFileSync(path_disclose_vkey) as unknown as string);
// verified_disclose = await groth16.verify(
// vkey_disclose,
// publicSignals_disclose,
// proof_disclose
// )
// console.log('\x1b[32m%s\x1b[0m', 'Proof verified - Disclose');
// rawCallData_disclose = await groth16.exportSolidityCallData(proof_disclose, publicSignals_disclose);
// parsedCallData_disclose = JSON.parse(`[${rawCallData_disclose}]`);
// formattedCallData_disclose = formatCallData_disclose(parsedCallData_disclose);
// // console.log('formattedCallData_disclose', formattedCallData_disclose);
// })
// it("SBT mint should succeed - SBT", async function () {
// await expect(sbt.mint(formattedCallData_disclose))
// .to.not.be.reverted;
// });
// // // refactor in generate inputs function
// // selector_dg1 = Array(90).fill("1");
// // scope = BigInt(1).toString();
// // user_address = await thirdAccount.getAddress();
// // majority = ["1", "8"];
// // input_disclose = generateCircuitInputsDisclose(
// // inputs.secret,
// // inputs.attestation_id,
// // passportData,
// // imt as any,
// // majority,
// // selector_dg1,
// // scope,
// // BigInt(user_address.toString()).toString()
// // );
// // // Generate the proof
// // console.log('\x1b[32m%s\x1b[0m', 'Generating proof - Disclose');
// // try {
// // proof_result_disclose = await groth16.fullProve(
// // input_disclose,
// // path_disclose_wasm,
// // path_disclose_zkey
// // );
// // } catch (error) {
// // console.error("Error generating proof:", error);
// // throw error;
// // }
// // proof_disclose = proof_result_disclose.proof;
// // publicSignals_disclose = proof_result_disclose.publicSignals;
// // assert(verified_disclose == true, 'Should verify')
// });
})

133
contracts/test/integrationTest/OneTimeVerification.ts
View File

@@ -1,45 +1,138 @@
import { ethers } from "hardhat";
import { expect } from "chai";
import { groth16 } from "snarkjs";
import {
VERIFICATION_TYPE_ENUM_PROVE,
VERIFICATION_TYPE_ENUM_DSC
} from "../../../common/src/constants/contractConstants";
import { PassportData } from "../../../common/src/utils/types";
import { genMockPassportData } from "../../../common/src/utils/genMockPassportData";
type CircuitArtifacts = {
[key: string]: {
wasm: string,
zkey: string,
vkey: string,
verifier?: any,
inputs?: any,
parsedCallData?: any,
formattedCallData?: any,
}
}
describe("Test one time verification flow", async function () {
this.timeout(0);
let verifierProveRsa65537Sha256: any;
// contracts
let verifiersManager: any;
let formatter: any;
let oneTimeSBT: any;
let verifierProveRsa65537Sha256: any;
let verifierDscRsa65537Sha256_4096: any;
// EVM state id
let snapshotId: any;
// users
let owner: any;
let addr1: any;
let addr2: any;
let snapshotId: any;
// mock passport
let mockPassport: PassportData = genMockPassportData(
"rsa_sha256",
"FRA",
"940131",
"401031"
);
let prove_circuits: CircuitArtifacts = {};
if (process.env.TEST_ENV === "local") {
prove_circuits["prove_rsa_65537_sha256"] = {
wasm: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_js/prove_rsa_65537_sha256.wasm",
zkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_final.zkey",
vkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_vkey.json"
}
} else if (process.env.TEST_ENV === "prod") {
prove_circuits["prove_rsa_65537_sha256"] = {
wasm: "../circuits/build/fromAWS/prove_rsa_65537_sha256.wasm",
zkey: "../circuits/build/fromAWS/prove_rsa_65537_sha256.zkey",
vkey: "../circuits/build/fromAWS/prove_rsa_65537_sha256_vkey.json"
}
} else {
prove_circuits["prove_rsa_65537_sha256"] = {
wasm: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_js/prove_rsa_65537_sha256.wasm",
zkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_final.zkey",
vkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_vkey.json"
}
}
let dsc_circuits: CircuitArtifacts = {};
dsc_circuits["dsc_rsa_65537_sha256_4096"] = {
wasm: "../circuits/build/dsc/dsc_rsa_65537_sha256_4096/dsc_rsa_65537_sha256_4096_js/dsc_rsa_65537_sha256_4096.wasm",
zkey: "../circuits/build/dsc/dsc_rsa_65537_sha256_4096/dsc_rsa_65537_sha256_4096_final.zkey",
vkey: "../circuits/build/dsc/dsc_rsa_65537_sha256_4096/dsc_rsa_65537_sha256_4096_vkey.json"
}
// if (process.env.TEST_ENV === "local") {
// prove_circuits["prove_rsa_65537_sha256"] = {
// wasm: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_js/prove_rsa_65537_sha256.wasm",
// zkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_final.zkey",
// vkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_vkey.json"
// }
// } else if (process.env.TEST_ENV === "prod") {
// prove_circuits["prove_rsa_65537_sha256"] = {
// wasm: "../circuits/build/fromAWS/prove_rsa_65537_sha256.wasm",
// zkey: "../circuits/build/fromAWS/prove_rsa_65537_sha256.zkey",
// vkey: "../circuits/build/fromAWS/prove_rsa_65537_sha256_vkey.json"
// }
// } else {
// prove_circuits["prove_rsa_65537_sha256"] = {
// wasm: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_js/prove_rsa_65537_sha256.wasm",
// zkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_final.zkey",
// vkey: "../circuits/build/prove/prove_rsa_65537_sha256/prove_rsa_65537_sha256_vkey.json"
// }
// }
before(async function() {
[owner, addr1, addr2] = await ethers.getSigners();
const testMode = process.argv[2];
// Set up contracts
let verifierProveRsa65537Sha256Factory: any;
if (testMode === "--local") {
verifierProveRsa65537Sha256Factory = await ethers.getContractFactory("contracts/verifiers/local/prove/Verifier_prove_rsa_65537_sha256.sol:Verifier_prove_rsa_65537_sha256");
} else if (testMode === "--prod") {
verifierProveRsa65537Sha256Factory = await ethers.getContractFactory("contracts/verifiers/prove/Verifier_prove_rsa_65537_sha256.sol:Verifier_prove_rsa_65537_sha256");
if (process.env.TEST_ENV === "local") {
verifierProveRsa65537Sha256Factory = await ethers.getContractFactory("contracts/verifiers/local/prove/Verifier_prove_rsa_65537_sha256.sol:Verifier_prove_rsa_65537_sha256", owner);
} else if (process.env.TEST_ENV === "prod") {
verifierProveRsa65537Sha256Factory = await ethers.getContractFactory("contracts/verifiers/prove/Verifier_prove_rsa_65537_sha256.sol:Verifier_prove_rsa_65537_sha256", owner);
} else {
verifierProveRsa65537Sha256Factory = await ethers.getContractFactory("contracts/verifiers/local/prove/Verifier_prove_rsa_65537_sha256.sol:Verifier_prove_rsa_65537_sha256", owner);
}
verifierProveRsa65537Sha256 = await verifierProveRsa65537Sha256Factory.deploy();
await verifierProveRsa65537Sha256.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `Verifier_prove_rsa_65537_sha256 deployed to ${verifierProveRsa65537Sha256.target}`);
const verifiersManagerFactory = await ethers.getContractFactory("VerifiersManager");
let verifierDscRsa65537Sha256_4096Factory: any;
if (process.env.TEST_ENV === "local") {
verifierDscRsa65537Sha256_4096Factory = await ethers.getContractFactory("contracts/verifiers/local/dsc/Verifier_dsc_rsa_65537_sha256_4096.sol:Verifier_dsc_rsa_65537_sha256_4096", owner);
} else if (process.env.TEST_ENV === "prod") {
verifierDscRsa65537Sha256_4096Factory = await ethers.getContractFactory("contracts/verifiers/dsc/Verifier_dsc_rsa_65537_sha256_4096.sol:Verifier_dsc_rsa_65537_sha256_4096", owner);
} else {
verifierDscRsa65537Sha256_4096Factory = await ethers.getContractFactory("contracts/verifiers/local/dsc/Verifier_dsc_rsa_65537_sha256_4096.sol:Verifier_dsc_rsa_65537_sha256_4096", owner);
}
verifierDscRsa65537Sha256_4096 = await verifierDscRsa65537Sha256_4096Factory.deploy();
await verifierDscRsa65537Sha256_4096.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `Verifier_dsc_rsa_65537_sha256_4096 deployed to ${verifierDscRsa65537Sha256_4096.target}`);
const verifiersManagerFactory = await ethers.getContractFactory("VerifiersManager", owner);
verifiersManager = await verifiersManagerFactory.deploy();
await verifiersManager.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `VerfiersManager deployed to ${verifiersManager.target}`);
const formatterFactory = await ethers.getContractFactory("Formatter");
const formatterFactory = await ethers.getContractFactory("Formatter", owner);
formatter = await formatterFactory.deploy();
await formatter.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `formatter deployed to ${formatter.target}`);
const sbtFactory = await ethers.getContractFactory("OneTimeSBT");
const sbtFactory = await ethers.getContractFactory("OneTimeSBT", owner);
oneTimeSBT = await sbtFactory.deploy(
verifiersManager,
formatter
@@ -47,6 +140,17 @@ describe("Test one time verification flow", async function () {
await oneTimeSBT.waitForDeployment();
console.log('\x1b[34m%s\x1b[0m', `sbt deployed to ${oneTimeSBT.target}`);
await verifiersManager.updateVerifier(
VERIFICATION_TYPE_ENUM_PROVE,
0,
verifierProveRsa65537Sha256.target
);
await verifiersManager.updateVerifier(
VERIFICATION_TYPE_ENUM_DSC,
0,
verifierDscRsa65537Sha256_4096.target
);
snapshotId = await ethers.provider.send("evm_snapshot", []);
});
@@ -54,4 +158,11 @@ describe("Test one time verification flow", async function () {
await ethers.provider.send("evm_revert", [snapshotId]);
snapshotId = await ethers.provider.send("evm_snapshot", []);
});
describe("test", async function() {
it("Should be able to deploy", async function() {
});
});
});

2
contracts/test/unitTest/OneTimeSBT.ts
View File

@@ -5,7 +5,7 @@ import {
generateMockRSAProveVerifierInputs,
generateMockDSCVerifierInputs,
convertProofTypeIntoInput
} from "../../../common/src/utils/unitTest/generateMockProof";
} from "../../../common/src/utils/test/generateMockProof";
const TRUE_VERIFIER_ID = 0;
const FALSE_VERIFIER_ID = 1;