From 1a18dd7ef7095a3e9f70b62d7a0b343b581e50a6 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Sun, 6 Oct 2024 12:51:56 +0900
Subject: [PATCH 01/10] fix script for build-dsc-circuit

---
 circuits/scripts/build_dsc_2048_circuits.sh   |   8 +-
 .../Verifier_dsc_rsa_65537_sha1_2048.sol      | 170 ++++++++++++++++++
 .../Verifier_dsc_rsapss_65537_sha256_2048.sol | 170 ++++++++++++++++++
 3 files changed, 344 insertions(+), 4 deletions(-)
 create mode 100644 contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol
 create mode 100644 contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol

diff --git a/circuits/scripts/build_dsc_2048_circuits.sh b/circuits/scripts/build_dsc_2048_circuits.sh
index ba1b9e42..8a69a115 100755
--- a/circuits/scripts/build_dsc_2048_circuits.sh
+++ b/circuits/scripts/build_dsc_2048_circuits.sh
@@ -19,7 +19,7 @@ build_circuit() {
     local START_TIME=$(date +%s)
 
     echo -e "\033[34mcompiling circuit: $CIRCUIT_NAME\033[0m"
-    circom circuits/tests/dsc/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build
+    circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build
 
     echo -e "\033[34mbuilding zkey\033[0m"
     yarn snarkjs groth16 setup build/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/${CIRCUIT_NAME}.zkey
@@ -51,9 +51,9 @@ build_circuit() {
 # Define circuits and their deployment flags
 # name:deploy_flag
 CIRCUITS=(
-    "dsc_sha256_rsapss_2048:true"
-    "dsc_sha256_rsa_2048:true"
-    "dsc_sha1_rsa_2048:true"
+    "dsc_rsapss_65537_sha256_2048:true"
+    "dsc_rsa_65537_sha256_2048:true"
+    "dsc_rsa_65537_sha1_2048:true"
 )
 
 for circuit in "${CIRCUITS[@]}"; do
diff --git a/contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol b/contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol
new file mode 100644
index 00000000..7122b69b
--- /dev/null
+++ b/contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Verifier_dsc_rsa_65537_sha1_2048 {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
+    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
+    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
+    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
+    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
+    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 4766268115133206610314787630727129782489543590682761993451136553076851288119;
+    uint256 constant deltax2 = 5420341533856142605013760188859731968341404568362419753467612950662716807764;
+    uint256 constant deltay1 = 13706411952733720514666924887158015540827903380267122705868403115221572932078;
+    uint256 constant deltay2 = 5543766965060474591092859527533560466945832976132663949845703590160092130664;
+
+    
+    uint256 constant IC0x = 17908967629137052474112707496771758069322926085845015877922295002210990593304;
+    uint256 constant IC0y = 6383432980722921245980814464336880189669518810415631731311068271009200302026;
+    
+    uint256 constant IC1x = 1868911144786195980344314843465071030593505744917955591036688774879590238260;
+    uint256 constant IC1y = 19547389766187324141997638990895875380087036691764223886503999972786274818899;
+    
+ 
+    // Memory data
+    uint16 constant pVk = 0;
+    uint16 constant pPairing = 128;
+
+    uint16 constant pLastMem = 896;
+
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) {
+        assembly {
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+            
+            // G1 function to multiply a G1 value(x,y) to value in an address
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn, 32), y)
+                mstore(add(mIn, 64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+
+                mstore(add(mIn, 64), mload(pR))
+                mstore(add(mIn, 96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+
+            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
+                let _pPairing := add(pMem, pPairing)
+                let _pVk := add(pMem, pVk)
+
+                mstore(_pVk, IC0x)
+                mstore(add(_pVk, 32), IC0y)
+
+                // Compute the linear combination vk_x
+                
+                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
+                
+
+                // -A
+                mstore(_pPairing, calldataload(pA))
+                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
+
+                // B
+                mstore(add(_pPairing, 64), calldataload(pB))
+                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
+                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
+                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
+
+                // alpha1
+                mstore(add(_pPairing, 192), alphax)
+                mstore(add(_pPairing, 224), alphay)
+
+                // beta2
+                mstore(add(_pPairing, 256), betax1)
+                mstore(add(_pPairing, 288), betax2)
+                mstore(add(_pPairing, 320), betay1)
+                mstore(add(_pPairing, 352), betay2)
+
+                // vk_x
+                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
+                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
+
+
+                // gamma2
+                mstore(add(_pPairing, 448), gammax1)
+                mstore(add(_pPairing, 480), gammax2)
+                mstore(add(_pPairing, 512), gammay1)
+                mstore(add(_pPairing, 544), gammay2)
+
+                // C
+                mstore(add(_pPairing, 576), calldataload(pC))
+                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
+
+                // delta2
+                mstore(add(_pPairing, 640), deltax1)
+                mstore(add(_pPairing, 672), deltax2)
+                mstore(add(_pPairing, 704), deltay1)
+                mstore(add(_pPairing, 736), deltay2)
+
+
+                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
+
+                isOk := and(success, mload(_pPairing))
+            }
+
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, pLastMem))
+
+            // Validate that all evaluations ∈ F
+            
+            checkField(calldataload(add(_pubSignals, 0)))
+            
+            checkField(calldataload(add(_pubSignals, 32)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }
diff --git a/contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol b/contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol
new file mode 100644
index 00000000..943635de
--- /dev/null
+++ b/contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Verifier_dsc_rsapss_65537_sha256_2048 {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
+    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
+    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
+    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
+    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
+    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 20750944040948293205235129837742665427980043253477347763135181580562864349782;
+    uint256 constant deltax2 = 19367007417304140595061814079021478596807088160740552708200765314130122361335;
+    uint256 constant deltay1 = 911205225690218878343339420436218110533574738192851546631473890561034124030;
+    uint256 constant deltay2 = 416799359668785031723065015671374385730091113859895605601821385687401014957;
+
+    
+    uint256 constant IC0x = 13946727458753698521402680377851722875067923384544948169783174191777177836447;
+    uint256 constant IC0y = 17849985628751165738408684253469034595472506936304780452870137032421959837082;
+    
+    uint256 constant IC1x = 9352428158600912067827704154087204016598570278103426164464615448114987091082;
+    uint256 constant IC1y = 19368944846597396863646034683545316739262021024043472849450581191116833574259;
+    
+ 
+    // Memory data
+    uint16 constant pVk = 0;
+    uint16 constant pPairing = 128;
+
+    uint16 constant pLastMem = 896;
+
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) {
+        assembly {
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+            
+            // G1 function to multiply a G1 value(x,y) to value in an address
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn, 32), y)
+                mstore(add(mIn, 64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+
+                mstore(add(mIn, 64), mload(pR))
+                mstore(add(mIn, 96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+
+            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
+                let _pPairing := add(pMem, pPairing)
+                let _pVk := add(pMem, pVk)
+
+                mstore(_pVk, IC0x)
+                mstore(add(_pVk, 32), IC0y)
+
+                // Compute the linear combination vk_x
+                
+                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
+                
+
+                // -A
+                mstore(_pPairing, calldataload(pA))
+                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
+
+                // B
+                mstore(add(_pPairing, 64), calldataload(pB))
+                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
+                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
+                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
+
+                // alpha1
+                mstore(add(_pPairing, 192), alphax)
+                mstore(add(_pPairing, 224), alphay)
+
+                // beta2
+                mstore(add(_pPairing, 256), betax1)
+                mstore(add(_pPairing, 288), betax2)
+                mstore(add(_pPairing, 320), betay1)
+                mstore(add(_pPairing, 352), betay2)
+
+                // vk_x
+                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
+                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
+
+
+                // gamma2
+                mstore(add(_pPairing, 448), gammax1)
+                mstore(add(_pPairing, 480), gammax2)
+                mstore(add(_pPairing, 512), gammay1)
+                mstore(add(_pPairing, 544), gammay2)
+
+                // C
+                mstore(add(_pPairing, 576), calldataload(pC))
+                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
+
+                // delta2
+                mstore(add(_pPairing, 640), deltax1)
+                mstore(add(_pPairing, 672), deltax2)
+                mstore(add(_pPairing, 704), deltay1)
+                mstore(add(_pPairing, 736), deltay2)
+
+
+                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
+
+                isOk := and(success, mload(_pPairing))
+            }
+
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, pLastMem))
+
+            // Validate that all evaluations ∈ F
+            
+            checkField(calldataload(add(_pubSignals, 0)))
+            
+            checkField(calldataload(add(_pubSignals, 32)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

From b7c69d618d856a3b209614592012fdd03deed731 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Sun, 6 Oct 2024 17:56:08 +0900
Subject: [PATCH 02/10] lint

---
 circuits/README.md | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/circuits/README.md b/circuits/README.md
index ecda7676..3ac16b66 100644
--- a/circuits/README.md
+++ b/circuits/README.md
@@ -71,10 +71,11 @@ yarn test
 
 This will run tests with sample data generated on the fly.
 
-
 ## OpenPassport Prove circuit
+
 OpenPassport Prove is the main circuit of the project.
 It is used for these 3 different `circuit modes`:
+
 - prove offChain
 - prove onChain
 - register
@@ -82,6 +83,7 @@ It is used for these 3 different `circuit modes`:
 Learn more on these 3 use cases on [OpenPassport documentation.](https://docs.openpassport.app/docs/use-openpassport/quickstart)
 
 The circuit achieves the following actions:
+
 - verify the signature of the passport and the integrity of the datagroups
 - disclose attributes
 - verify that user's name is not part of the OFAC list
@@ -93,23 +95,21 @@ If this "everything circuit" is executing all those actions each time, we want a
 
 In order to achieve that we will input a bitmap `selector_mode[2]` that will ensure that the circuit can only disclose the attributes related to the `circuit mode` selected.
 
-| Circuit Mode | selector_mode[0] | selector_mode[1] |
-| --- | --- | --- |
-| prove offChain | 1 | 1 |
-| prove onChain | 1 | 0 |
-| register | 0 | 0 |
+| Circuit Mode   | selector_mode[0] | selector_mode[1] |
+| -------------- | ---------------- | ---------------- |
+| prove offChain | 1                | 1                |
+| prove onChain  | 1                | 0                |
+| register       | 0                | 0                |
 
 Using the value [0,1] for `selector_mode` will fail proof generation.
 
-
 Here are the attributes disclosed according to the `circuit_mode`:
 
-| Circuit Mode | Attributes Disclosed |
-| --- | --- |
-| prove offChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, pubKey |
-| prove onChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, blinded DSC commitment |
-| register | blinded DSC commitment, commitment |
-
+| Circuit Mode   | Attributes Disclosed                                                           |
+| -------------- | ------------------------------------------------------------------------------ |
+| prove offChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, pubKey                 |
+| prove onChain  | packedReveal-dg1, older than, OFAC, countryIsNotInList, blinded DSC commitment |
+| register       | blinded DSC commitment, commitment                                             |
 
 ## Certificate Chain verification
 
@@ -119,7 +119,9 @@ Both DSC and CSCA lists are published on online registry of the ICAO, however ma
 In order to maximize passport readability we need to verify the full certificate chain.
 
 ### On chain
+
 To avoid huge proving time and (too) heavy zkeys, the signature of the passport data is verified on the mobile (the passport data never leaves the device) and the certificate chain verification is done on a remote modal server. A `blindedDscCommitment` is generated on both sides to link proofs.
 
 ### Off chain
-In off chain setup users will send their DSC to the verifier along with their passport proof. The pubKey will be revealed as an output of the proof.
\ No newline at end of file
+
+In off chain setup users will send their DSC to the verifier along with their passport proof. The pubKey will be revealed as an output of the proof.

From c49215bc9d3c1317116b53d70aedf3583844c03e Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Sun, 6 Oct 2024 18:47:15 +0900
Subject: [PATCH 03/10] add build script for dislose circuits

---
 circuits/scripts/build_disclose_circuit.sh    |  51 ++++
 .../disclose/Verifier_vc_and_disclose.sol     | 275 ++++++++++++++++++
 2 files changed, 326 insertions(+)
 create mode 100755 circuits/scripts/build_disclose_circuit.sh
 create mode 100644 contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol

diff --git a/circuits/scripts/build_disclose_circuit.sh b/circuits/scripts/build_disclose_circuit.sh
new file mode 100755
index 00000000..e430aeff
--- /dev/null
+++ b/circuits/scripts/build_disclose_circuit.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+source "scripts/download_ptau.sh"
+
+build_circuit() {
+    local CIRCUIT_NAME=$1
+    local CIRCUIT_TYPE=$2
+    local START_TIME=$(date +%s)
+
+    echo "compiling circuit: $CIRCUIT_NAME"
+    circom circuits/${CIRCUIT_TYPE}/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits/ --r1cs --O1 --wasm -c --output build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/
+
+    echo "building zkey"
+    yarn snarkjs groth16 setup build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
+
+    echo "building vkey"
+    yarn snarkjs zkey contribute build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey -e="random text"
+    yarn snarkjs zkey export verificationkey build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}_vkey.json
+
+    yarn snarkjs zkey export solidityverifier build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
+    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
+    cp build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/verifiers//${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
+    echo "copied Verifier_${CIRCUIT_NAME}.sol to contracts"
+
+    echo "Build of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds"
+    echo "Size of ${CIRCUIT_NAME}.r1cs: $(wc -c <build/${CIRCUIT_NAME}.r1cs) bytes"
+    echo "Size of ${CIRCUIT_NAME}.wasm: $(wc -c <build/${CIRCUIT_NAME}_js/${CIRCUIT_NAME}.wasm) bytes"
+    echo "Size of ${CIRCUIT_NAME}_final.zkey: $(wc -c <build/${CIRCUIT_NAME}_final.zkey) bytes"
+}
+
+# Define circuits and their types
+# name:folder:build_flag
+# set build_flag to false if you want to skip the build
+CIRCUITS=(
+    "vc_and_disclose:disclose:20:true"
+    "disclose:disclose:20:false"
+    "proveCountryIsNotInList:disclose:20:false"
+    "verify_commitment:disclose:22:false"
+)
+
+TOTAL_START_TIME=$(date +%s)
+for circuit in "${CIRCUITS[@]}"; do
+    IFS=':' read -r CIRCUIT_NAME CIRCUIT_TYPE POWEROFTAU BUILD_FLAG <<< "$circuit"
+    if [ "$BUILD_FLAG" = "true" ]; then
+        echo "Debug: Building circuit $CIRCUIT_NAME of type $CIRCUIT_TYPE"
+        build_circuit "$CIRCUIT_NAME" "$CIRCUIT_TYPE"
+    else
+        echo "Skipping build for $CIRCUIT_NAME"
+    fi
+done
+echo "Total completed in $(($(date +%s) - TOTAL_START_TIME)) seconds"
\ No newline at end of file
diff --git a/contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol b/contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol
new file mode 100644
index 00000000..e03b75a8
--- /dev/null
+++ b/contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol
@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Verifier_vc_and_disclose {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
+    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
+    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
+    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
+    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
+    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 17414664872893519830503133087831113966898464613172259182120645460266886438539;
+    uint256 constant deltax2 = 17445258621513904484076939439365293726203186253030158219187200821865161670097;
+    uint256 constant deltay1 = 5213039550532744829449049599799107763468819757329084510013742838292370949828;
+    uint256 constant deltay2 = 15869132183345070916910982820810244002100961039851502709137820952731786036518;
+
+    
+    uint256 constant IC0x = 11699064754201195007398527350253348403151481002046977275974914515794556464907;
+    uint256 constant IC0y = 8377098824516723042209547366307545575336194904666442740719435968971891137137;
+    
+    uint256 constant IC1x = 15022578671217433728263017879847504938124709144805899886585104521700250021138;
+    uint256 constant IC1y = 7439374227934829324841183186890967124081563506556263992139697902117577630383;
+    
+    uint256 constant IC2x = 8719884923846896418670370483026242120279461454392494350543596555692392150751;
+    uint256 constant IC2y = 1915572466121040401254047597591235959434056701873531529685278614032487740057;
+    
+    uint256 constant IC3x = 15854458635547661044046209019901121787893952481692645870771021335496255904066;
+    uint256 constant IC3y = 18580362195513971727529458597180322208793324937796157274539580854125510824273;
+    
+    uint256 constant IC4x = 20197620246128797797969231334172536167724314393789981313273934960930874757904;
+    uint256 constant IC4y = 8652383402530547452977109949475477447090780660216084329098279248059527858257;
+    
+    uint256 constant IC5x = 6136418035854024647800871603208064108329169082713292338157990550507679741373;
+    uint256 constant IC5y = 4148249731111469783390189175626927778451683234448732196893033887074109584641;
+    
+    uint256 constant IC6x = 435016271093619026896979316149581362925836421109084185028857731123245432006;
+    uint256 constant IC6y = 21254951437721821548232352310541329777023953579777485090776415227787346519751;
+    
+    uint256 constant IC7x = 21278075374621156162040667851377496500311461883308769905293308585207243513686;
+    uint256 constant IC7y = 12203663506086881329872300647846774063295289884666082497820328056490027198813;
+    
+    uint256 constant IC8x = 16308483425091511705934563714250777026234740651509189582674872217820098595375;
+    uint256 constant IC8y = 7831547100064998764922162707495490598633878334974466872347123357740110689244;
+    
+    uint256 constant IC9x = 3291127262603144718778205947439511714981876162713868160237600958297179548397;
+    uint256 constant IC9y = 21485037857784329908791414402133986495597755287969373075934534732305491839766;
+    
+    uint256 constant IC10x = 21016409257036220162904188391746628812174550025367627914783879782321883872463;
+    uint256 constant IC10y = 771625434822550883448227440257963423499310868732489728802518320854402128338;
+    
+    uint256 constant IC11x = 848677157837511141352835832315266404476623536713045891337491496271705963639;
+    uint256 constant IC11y = 8217347855861380271136078798483880852994161288399697316508954130226938484979;
+    
+    uint256 constant IC12x = 7950645217739479484822823131266057021165813197226380213090258700020405406040;
+    uint256 constant IC12y = 21115671325929956654785783064024579377805406512650003241388844210050677251719;
+    
+    uint256 constant IC13x = 3626770947109436638554139078198740121299601968895373800820851494276106181151;
+    uint256 constant IC13y = 1231434625641659068142386110297841563481701042171599336083256459050627128218;
+    
+    uint256 constant IC14x = 16049947947771356656284191511201202183176568879064579206986716057573639688339;
+    uint256 constant IC14y = 6480470373974113105161133752760352489238403926514542525269014451361964382448;
+    
+    uint256 constant IC15x = 16974167980812170374822233712683695773735295177444364620936821746333456881288;
+    uint256 constant IC15y = 8122261017527118496247636440450416615732682768376367625137811781672190179076;
+    
+    uint256 constant IC16x = 4370481621955946039258820475154973643976715870021068098944543782894438093187;
+    uint256 constant IC16y = 9625487063950556055947770382866627694768814221480630062831377989311939157072;
+    
+ 
+    // Memory data
+    uint16 constant pVk = 0;
+    uint16 constant pPairing = 128;
+
+    uint16 constant pLastMem = 896;
+
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[16] calldata _pubSignals) public view returns (bool) {
+        assembly {
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+            
+            // G1 function to multiply a G1 value(x,y) to value in an address
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn, 32), y)
+                mstore(add(mIn, 64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+
+                mstore(add(mIn, 64), mload(pR))
+                mstore(add(mIn, 96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+
+            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
+                let _pPairing := add(pMem, pPairing)
+                let _pVk := add(pMem, pVk)
+
+                mstore(_pVk, IC0x)
+                mstore(add(_pVk, 32), IC0y)
+
+                // Compute the linear combination vk_x
+                
+                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
+                
+                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
+                
+                g1_mulAccC(_pVk, IC3x, IC3y, calldataload(add(pubSignals, 64)))
+                
+                g1_mulAccC(_pVk, IC4x, IC4y, calldataload(add(pubSignals, 96)))
+                
+                g1_mulAccC(_pVk, IC5x, IC5y, calldataload(add(pubSignals, 128)))
+                
+                g1_mulAccC(_pVk, IC6x, IC6y, calldataload(add(pubSignals, 160)))
+                
+                g1_mulAccC(_pVk, IC7x, IC7y, calldataload(add(pubSignals, 192)))
+                
+                g1_mulAccC(_pVk, IC8x, IC8y, calldataload(add(pubSignals, 224)))
+                
+                g1_mulAccC(_pVk, IC9x, IC9y, calldataload(add(pubSignals, 256)))
+                
+                g1_mulAccC(_pVk, IC10x, IC10y, calldataload(add(pubSignals, 288)))
+                
+                g1_mulAccC(_pVk, IC11x, IC11y, calldataload(add(pubSignals, 320)))
+                
+                g1_mulAccC(_pVk, IC12x, IC12y, calldataload(add(pubSignals, 352)))
+                
+                g1_mulAccC(_pVk, IC13x, IC13y, calldataload(add(pubSignals, 384)))
+                
+                g1_mulAccC(_pVk, IC14x, IC14y, calldataload(add(pubSignals, 416)))
+                
+                g1_mulAccC(_pVk, IC15x, IC15y, calldataload(add(pubSignals, 448)))
+                
+                g1_mulAccC(_pVk, IC16x, IC16y, calldataload(add(pubSignals, 480)))
+                
+
+                // -A
+                mstore(_pPairing, calldataload(pA))
+                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
+
+                // B
+                mstore(add(_pPairing, 64), calldataload(pB))
+                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
+                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
+                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
+
+                // alpha1
+                mstore(add(_pPairing, 192), alphax)
+                mstore(add(_pPairing, 224), alphay)
+
+                // beta2
+                mstore(add(_pPairing, 256), betax1)
+                mstore(add(_pPairing, 288), betax2)
+                mstore(add(_pPairing, 320), betay1)
+                mstore(add(_pPairing, 352), betay2)
+
+                // vk_x
+                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
+                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
+
+
+                // gamma2
+                mstore(add(_pPairing, 448), gammax1)
+                mstore(add(_pPairing, 480), gammax2)
+                mstore(add(_pPairing, 512), gammay1)
+                mstore(add(_pPairing, 544), gammay2)
+
+                // C
+                mstore(add(_pPairing, 576), calldataload(pC))
+                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
+
+                // delta2
+                mstore(add(_pPairing, 640), deltax1)
+                mstore(add(_pPairing, 672), deltax2)
+                mstore(add(_pPairing, 704), deltay1)
+                mstore(add(_pPairing, 736), deltay2)
+
+
+                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
+
+                isOk := and(success, mload(_pPairing))
+            }
+
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, pLastMem))
+
+            // Validate that all evaluations ∈ F
+            
+            checkField(calldataload(add(_pubSignals, 0)))
+            
+            checkField(calldataload(add(_pubSignals, 32)))
+            
+            checkField(calldataload(add(_pubSignals, 64)))
+            
+            checkField(calldataload(add(_pubSignals, 96)))
+            
+            checkField(calldataload(add(_pubSignals, 128)))
+            
+            checkField(calldataload(add(_pubSignals, 160)))
+            
+            checkField(calldataload(add(_pubSignals, 192)))
+            
+            checkField(calldataload(add(_pubSignals, 224)))
+            
+            checkField(calldataload(add(_pubSignals, 256)))
+            
+            checkField(calldataload(add(_pubSignals, 288)))
+            
+            checkField(calldataload(add(_pubSignals, 320)))
+            
+            checkField(calldataload(add(_pubSignals, 352)))
+            
+            checkField(calldataload(add(_pubSignals, 384)))
+            
+            checkField(calldataload(add(_pubSignals, 416)))
+            
+            checkField(calldataload(add(_pubSignals, 448)))
+            
+            checkField(calldataload(add(_pubSignals, 480)))
+            
+            checkField(calldataload(add(_pubSignals, 512)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

From 72fde0e145a9b48b8d95277236c9c7696fe8ef02 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Sun, 6 Oct 2024 19:05:35 +0900
Subject: [PATCH 04/10] fix readme

---
 circuits/README.md                          | 30 ++++++++++-----------
 circuits/scripts/build_dsc_2048_circuits.sh | 15 ++++++-----
 circuits/scripts/build_dsc_4096_circuits.sh | 15 ++++++-----
 3 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/circuits/README.md b/circuits/README.md
index 3ac16b66..ecda7676 100644
--- a/circuits/README.md
+++ b/circuits/README.md
@@ -71,11 +71,10 @@ yarn test
 
 This will run tests with sample data generated on the fly.
 
-## OpenPassport Prove circuit
 
+## OpenPassport Prove circuit
 OpenPassport Prove is the main circuit of the project.
 It is used for these 3 different `circuit modes`:
-
 - prove offChain
 - prove onChain
 - register
@@ -83,7 +82,6 @@ It is used for these 3 different `circuit modes`:
 Learn more on these 3 use cases on [OpenPassport documentation.](https://docs.openpassport.app/docs/use-openpassport/quickstart)
 
 The circuit achieves the following actions:
-
 - verify the signature of the passport and the integrity of the datagroups
 - disclose attributes
 - verify that user's name is not part of the OFAC list
@@ -95,21 +93,23 @@ If this "everything circuit" is executing all those actions each time, we want a
 
 In order to achieve that we will input a bitmap `selector_mode[2]` that will ensure that the circuit can only disclose the attributes related to the `circuit mode` selected.
 
-| Circuit Mode   | selector_mode[0] | selector_mode[1] |
-| -------------- | ---------------- | ---------------- |
-| prove offChain | 1                | 1                |
-| prove onChain  | 1                | 0                |
-| register       | 0                | 0                |
+| Circuit Mode | selector_mode[0] | selector_mode[1] |
+| --- | --- | --- |
+| prove offChain | 1 | 1 |
+| prove onChain | 1 | 0 |
+| register | 0 | 0 |
 
 Using the value [0,1] for `selector_mode` will fail proof generation.
 
+
 Here are the attributes disclosed according to the `circuit_mode`:
 
-| Circuit Mode   | Attributes Disclosed                                                           |
-| -------------- | ------------------------------------------------------------------------------ |
-| prove offChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, pubKey                 |
-| prove onChain  | packedReveal-dg1, older than, OFAC, countryIsNotInList, blinded DSC commitment |
-| register       | blinded DSC commitment, commitment                                             |
+| Circuit Mode | Attributes Disclosed |
+| --- | --- |
+| prove offChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, pubKey |
+| prove onChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, blinded DSC commitment |
+| register | blinded DSC commitment, commitment |
+
 
 ## Certificate Chain verification
 
@@ -119,9 +119,7 @@ Both DSC and CSCA lists are published on online registry of the ICAO, however ma
 In order to maximize passport readability we need to verify the full certificate chain.
 
 ### On chain
-
 To avoid huge proving time and (too) heavy zkeys, the signature of the passport data is verified on the mobile (the passport data never leaves the device) and the certificate chain verification is done on a remote modal server. A `blindedDscCommitment` is generated on both sides to link proofs.
 
 ### Off chain
-
-In off chain setup users will send their DSC to the verifier along with their passport proof. The pubKey will be revealed as an output of the proof.
+In off chain setup users will send their DSC to the verifier along with their passport proof. The pubKey will be revealed as an output of the proof.
\ No newline at end of file
diff --git a/circuits/scripts/build_dsc_2048_circuits.sh b/circuits/scripts/build_dsc_2048_circuits.sh
index 8a69a115..d7aa5350 100755
--- a/circuits/scripts/build_dsc_2048_circuits.sh
+++ b/circuits/scripts/build_dsc_2048_circuits.sh
@@ -19,10 +19,11 @@ build_circuit() {
     local START_TIME=$(date +%s)
 
     echo -e "\033[34mcompiling circuit: $CIRCUIT_NAME\033[0m"
-    circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build
+    mkdir -p ./build/dsc/${CIRCUIT_NAME}/
+    circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build/dsc/${CIRCUIT_NAME}/
 
     echo -e "\033[34mbuilding zkey\033[0m"
-    yarn snarkjs groth16 setup build/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/${CIRCUIT_NAME}.zkey
+    yarn snarkjs groth16 setup build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
 
     if command -v openssl &> /dev/null
     then
@@ -32,12 +33,12 @@ build_circuit() {
     fi
 
     echo -e "\033[34mbuilding vkey\033[0m"
-    echo $RAND_STR | yarn snarkjs zkey contribute build/${CIRCUIT_NAME}.zkey build/${CIRCUIT_NAME}_final.zkey
-    yarn snarkjs zkey export verificationkey build/${CIRCUIT_NAME}_final.zkey build/${CIRCUIT_NAME}_vkey.json
+    echo $RAND_STR | yarn snarkjs zkey contribute build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey
+    yarn snarkjs zkey export verificationkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_vkey.json
 
-    yarn snarkjs zkey export solidityverifier build/${CIRCUIT_NAME}_final.zkey build/Verifier_${CIRCUIT_NAME}.sol
-    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/Verifier_${CIRCUIT_NAME}.sol
-    cp build/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/Verifier_${CIRCUIT_NAME}.sol
+    yarn snarkjs zkey export solidityverifier build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/Verifier_${CIRCUIT_NAME}.sol
+    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/dsc/Verifier_${CIRCUIT_NAME}.sol
+    cp build/dsc/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/dsc/Verifier_${CIRCUIT_NAME}.sol
     echo -e "\033[34mcopied Verifier_${CIRCUIT_NAME}.sol to contracts\033[0m"
 
     echo -e "\033[32mBuild of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds\033[0m"
diff --git a/circuits/scripts/build_dsc_4096_circuits.sh b/circuits/scripts/build_dsc_4096_circuits.sh
index c88b8bfe..d92d765e 100755
--- a/circuits/scripts/build_dsc_4096_circuits.sh
+++ b/circuits/scripts/build_dsc_4096_circuits.sh
@@ -19,10 +19,11 @@ build_circuit() {
     local START_TIME=$(date +%s)
 
     echo -e "\033[34mcompiling circuit: $CIRCUIT_NAME\033[0m"
-    circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build
+    mkdir -p ./build/dsc/${CIRCUIT_NAME}/
+    circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build/dsc/${CIRCUIT_NAME}/
 
     echo -e "\033[34mbuilding zkey\033[0m"
-    NODE_OPTIONS="--max-old-space-size=8192" yarn snarkjs groth16 setup build/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_22.ptau build/${CIRCUIT_NAME}.zkey
+    NODE_OPTIONS="--max-old-space-size=8192" yarn snarkjs groth16 setup build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_22.ptau build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
 
     if command -v openssl &> /dev/null
     then
@@ -32,12 +33,12 @@ build_circuit() {
     fi
 
     echo -e "\033[34mbuilding vkey\033[0m"
-    echo $RAND_STR | yarn snarkjs zkey contribute build/${CIRCUIT_NAME}.zkey build/${CIRCUIT_NAME}_final.zkey
-    yarn snarkjs zkey export verificationkey build/${CIRCUIT_NAME}_final.zkey build/${CIRCUIT_NAME}_vkey.json
+    echo $RAND_STR | yarn snarkjs zkey contribute build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey
+    yarn snarkjs zkey export verificationkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_vkey.json
 
-    yarn snarkjs zkey export solidityverifier build/${CIRCUIT_NAME}_final.zkey build/Verifier_${CIRCUIT_NAME}.sol
-    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/Verifier_${CIRCUIT_NAME}.sol
-    cp build/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/Verifier_${CIRCUIT_NAME}.sol
+    yarn snarkjs zkey export solidityverifier build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/Verifier_${CIRCUIT_NAME}.sol
+    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/dsc/Verifier_${CIRCUIT_NAME}.sol
+    cp build/dsc/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/dsc/Verifier_${CIRCUIT_NAME}.sol
     echo -e "\033[34mcopied Verifier_${CIRCUIT_NAME}.sol to contracts\033[0m"
 
     echo -e "\033[32mBuild of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds\033[0m"

From 727abb85bd8ec7fbc870ccb26fc48b941fec4f68 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Sun, 6 Oct 2024 21:10:35 +0900
Subject: [PATCH 05/10] fix lint

---
 circuits/README.md | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/circuits/README.md b/circuits/README.md
index ecda7676..3ac16b66 100644
--- a/circuits/README.md
+++ b/circuits/README.md
@@ -71,10 +71,11 @@ yarn test
 
 This will run tests with sample data generated on the fly.
 
-
 ## OpenPassport Prove circuit
+
 OpenPassport Prove is the main circuit of the project.
 It is used for these 3 different `circuit modes`:
+
 - prove offChain
 - prove onChain
 - register
@@ -82,6 +83,7 @@ It is used for these 3 different `circuit modes`:
 Learn more on these 3 use cases on [OpenPassport documentation.](https://docs.openpassport.app/docs/use-openpassport/quickstart)
 
 The circuit achieves the following actions:
+
 - verify the signature of the passport and the integrity of the datagroups
 - disclose attributes
 - verify that user's name is not part of the OFAC list
@@ -93,23 +95,21 @@ If this "everything circuit" is executing all those actions each time, we want a
 
 In order to achieve that we will input a bitmap `selector_mode[2]` that will ensure that the circuit can only disclose the attributes related to the `circuit mode` selected.
 
-| Circuit Mode | selector_mode[0] | selector_mode[1] |
-| --- | --- | --- |
-| prove offChain | 1 | 1 |
-| prove onChain | 1 | 0 |
-| register | 0 | 0 |
+| Circuit Mode   | selector_mode[0] | selector_mode[1] |
+| -------------- | ---------------- | ---------------- |
+| prove offChain | 1                | 1                |
+| prove onChain  | 1                | 0                |
+| register       | 0                | 0                |
 
 Using the value [0,1] for `selector_mode` will fail proof generation.
 
-
 Here are the attributes disclosed according to the `circuit_mode`:
 
-| Circuit Mode | Attributes Disclosed |
-| --- | --- |
-| prove offChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, pubKey |
-| prove onChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, blinded DSC commitment |
-| register | blinded DSC commitment, commitment |
-
+| Circuit Mode   | Attributes Disclosed                                                           |
+| -------------- | ------------------------------------------------------------------------------ |
+| prove offChain | packedReveal-dg1, older than, OFAC, countryIsNotInList, pubKey                 |
+| prove onChain  | packedReveal-dg1, older than, OFAC, countryIsNotInList, blinded DSC commitment |
+| register       | blinded DSC commitment, commitment                                             |
 
 ## Certificate Chain verification
 
@@ -119,7 +119,9 @@ Both DSC and CSCA lists are published on online registry of the ICAO, however ma
 In order to maximize passport readability we need to verify the full certificate chain.
 
 ### On chain
+
 To avoid huge proving time and (too) heavy zkeys, the signature of the passport data is verified on the mobile (the passport data never leaves the device) and the certificate chain verification is done on a remote modal server. A `blindedDscCommitment` is generated on both sides to link proofs.
 
 ### Off chain
-In off chain setup users will send their DSC to the verifier along with their passport proof. The pubKey will be revealed as an output of the proof.
\ No newline at end of file
+
+In off chain setup users will send their DSC to the verifier along with their passport proof. The pubKey will be revealed as an output of the proof.

From 729985e2d35c905d1f84eed178681249c83872f3 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Mon, 7 Oct 2024 23:14:48 +0900
Subject: [PATCH 06/10] add build_disclose_circuit.sh and fix each build
 scripts

---
 circuits/scripts/build_disclose_circuit.sh  |  4 +++-
 circuits/scripts/build_dsc_2048_circuits.sh | 11 +++++----
 circuits/scripts/build_prove_circuits.sh    | 26 +++++++++++----------
 contracts/.gitignore                        |  5 +++-
 4 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/circuits/scripts/build_disclose_circuit.sh b/circuits/scripts/build_disclose_circuit.sh
index e430aeff..79a2631b 100755
--- a/circuits/scripts/build_disclose_circuit.sh
+++ b/circuits/scripts/build_disclose_circuit.sh
@@ -8,6 +8,7 @@ build_circuit() {
     local START_TIME=$(date +%s)
 
     echo "compiling circuit: $CIRCUIT_NAME"
+    mkdir -p build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/
     circom circuits/${CIRCUIT_TYPE}/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits/ --r1cs --O1 --wasm -c --output build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/
 
     echo "building zkey"
@@ -19,7 +20,8 @@ build_circuit() {
 
     yarn snarkjs zkey export solidityverifier build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
     sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
-    cp build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/verifiers//${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
+    mkdir -p ../contracts/contracts/verifiers/local/${CIRCUIT_TYPE}/
+    cp build/${CIRCUIT_TYPE}/${CIRCUIT_NAME}/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/verifiers/local/${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
     echo "copied Verifier_${CIRCUIT_NAME}.sol to contracts"
 
     echo "Build of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds"
diff --git a/circuits/scripts/build_dsc_2048_circuits.sh b/circuits/scripts/build_dsc_2048_circuits.sh
index d7aa5350..fb29a067 100755
--- a/circuits/scripts/build_dsc_2048_circuits.sh
+++ b/circuits/scripts/build_dsc_2048_circuits.sh
@@ -23,7 +23,7 @@ build_circuit() {
     circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build/dsc/${CIRCUIT_NAME}/
 
     echo -e "\033[34mbuilding zkey\033[0m"
-    yarn snarkjs groth16 setup build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
+    yarn snarkjs groth16 setup build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_22.ptau build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
 
     if command -v openssl &> /dev/null
     then
@@ -33,12 +33,13 @@ build_circuit() {
     fi
 
     echo -e "\033[34mbuilding vkey\033[0m"
-    echo $RAND_STR | yarn snarkjs zkey contribute build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey
+    yarn snarkjs zkey contribute build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey -e="random text"
     yarn snarkjs zkey export verificationkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_vkey.json
 
     yarn snarkjs zkey export solidityverifier build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/Verifier_${CIRCUIT_NAME}.sol
     sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/dsc/Verifier_${CIRCUIT_NAME}.sol
-    cp build/dsc/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/dsc/Verifier_${CIRCUIT_NAME}.sol
+    mkdir -p ../contracts/contracts/local/dsc/
+    cp build/dsc/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/local/dsc/Verifier_${CIRCUIT_NAME}.sol
     echo -e "\033[34mcopied Verifier_${CIRCUIT_NAME}.sol to contracts\033[0m"
 
     echo -e "\033[32mBuild of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds\033[0m"
@@ -52,9 +53,9 @@ build_circuit() {
 # Define circuits and their deployment flags
 # name:deploy_flag
 CIRCUITS=(
-    "dsc_rsapss_65537_sha256_2048:true"
+    "dsc_rsapss_65537_sha256_2048:false"
     "dsc_rsa_65537_sha256_2048:true"
-    "dsc_rsa_65537_sha1_2048:true"
+    "dsc_rsa_65537_sha1_2048:false"
 )
 
 for circuit in "${CIRCUITS[@]}"; do
diff --git a/circuits/scripts/build_prove_circuits.sh b/circuits/scripts/build_prove_circuits.sh
index b935e6bc..7bdddf9d 100755
--- a/circuits/scripts/build_prove_circuits.sh
+++ b/circuits/scripts/build_prove_circuits.sh
@@ -8,24 +8,26 @@ build_circuit() {
     local START_TIME=$(date +%s)
 
     echo "compiling circuit: $CIRCUIT_NAME"
-    circom circuits/${CIRCUIT_TYPE}/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build
+    mkdir -p build/prove/${CIRCUIT_NAME}/
+    circom circuits/${CIRCUIT_TYPE}/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build/prove/${CIRCUIT_NAME}/
 
     echo "building zkey"
-    yarn snarkjs groth16 setup build/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/${CIRCUIT_NAME}.zkey
+    yarn snarkjs groth16 setup build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_20.ptau build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
 
     echo "building vkey"
-    yarn snarkjs zkey contribute build/${CIRCUIT_NAME}.zkey build/${CIRCUIT_NAME}_final.zkey -e="random text"
-    yarn snarkjs zkey export verificationkey build/${CIRCUIT_NAME}_final.zkey build/${CIRCUIT_NAME}_vkey.json
+    yarn snarkjs zkey contribute build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey -e="random text"
+    yarn snarkjs zkey export verificationkey build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}_vkey.json
 
-    yarn snarkjs zkey export solidityverifier build/${CIRCUIT_NAME}_final.zkey build/Verifier_${CIRCUIT_NAME}.sol
-    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/Verifier_${CIRCUIT_NAME}.sol
-    cp build/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/Verifier_${CIRCUIT_NAME}.sol
+    yarn snarkjs zkey export solidityverifier build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/prove/${CIRCUIT_NAME}/Verifier_${CIRCUIT_NAME}.sol
+    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/prove/${CIRCUIT_NAME}/Verifier_${CIRCUIT_NAME}.sol
+    mkdir -p ../contracts/contracts/verifiers/local/${CIRCUIT_TYPE}/
+    cp build/prove/${CIRCUIT_NAME}/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/verifiers/local/${CIRCUIT_TYPE}/Verifier_${CIRCUIT_NAME}.sol
     echo "copied Verifier_${CIRCUIT_NAME}.sol to contracts"
 
     echo "Build of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds"
-    echo "Size of ${CIRCUIT_NAME}.r1cs: $(wc -c <build/${CIRCUIT_NAME}.r1cs) bytes"
-    echo "Size of ${CIRCUIT_NAME}.wasm: $(wc -c <build/${CIRCUIT_NAME}_js/${CIRCUIT_NAME}.wasm) bytes"
-    echo "Size of ${CIRCUIT_NAME}_final.zkey: $(wc -c <build/${CIRCUIT_NAME}_final.zkey) bytes"
+    echo "Size of ${CIRCUIT_NAME}.r1cs: $(wc -c <build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs) bytes"
+    echo "Size of ${CIRCUIT_NAME}.wasm: $(wc -c <build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}_js/${CIRCUIT_NAME}.wasm) bytes"
+    echo "Size of ${CIRCUIT_NAME}_final.zkey: $(wc -c <build/prove/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey) bytes"
 }
 
 # Define circuits and their types
@@ -33,8 +35,8 @@ build_circuit() {
 # set build_flag to false if you want to skip the build
 CIRCUITS=(
     "prove_rsa_65537_sha256:prove:20:true"
-    "prove_rsa_65537_sha1:prove:20:true"
-    "prove_rsapss_65537_sha256:prove:20:true"
+    "prove_rsa_65537_sha1:prove:20:false"
+    "prove_rsapss_65537_sha256:prove:20:false"
     "prove_ecdsa_secp256r1_sha256:prove:22:false"
     "prove_ecdsa_secp256r1_sha1:prove:22:false"
 )
diff --git a/contracts/.gitignore b/contracts/.gitignore
index 3591bac9..27eeebd3 100644
--- a/contracts/.gitignore
+++ b/contracts/.gitignore
@@ -10,4 +10,7 @@ cache
 artifacts
 ignition/deployed_addresses.json
 ignition/parameters.json
-ignition/deployments
\ No newline at end of file
+ignition/deployments
+
+#Local verifier
+contracts/verifiers/local/*
\ No newline at end of file

From ef9956e4f7d9a8a732e82a7a21ec75d6a2a1ae76 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Mon, 7 Oct 2024 23:16:42 +0900
Subject: [PATCH 07/10] delete not ideal files

---
 .../Verifier_dsc_rsa_65537_sha1_2048.sol      | 170 -----------
 .../Verifier_dsc_rsapss_65537_sha256_2048.sol | 170 -----------
 .../disclose/Verifier_vc_and_disclose.sol     | 275 ------------------
 3 files changed, 615 deletions(-)
 delete mode 100644 contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol
 delete mode 100644 contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol
 delete mode 100644 contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol

diff --git a/contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol b/contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol
deleted file mode 100644
index 7122b69b..00000000
--- a/contracts/contracts/Verifier_dsc_rsa_65537_sha1_2048.sol
+++ /dev/null
@@ -1,170 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_rsa_65537_sha1_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 4766268115133206610314787630727129782489543590682761993451136553076851288119;
-    uint256 constant deltax2 = 5420341533856142605013760188859731968341404568362419753467612950662716807764;
-    uint256 constant deltay1 = 13706411952733720514666924887158015540827903380267122705868403115221572932078;
-    uint256 constant deltay2 = 5543766965060474591092859527533560466945832976132663949845703590160092130664;
-
-    
-    uint256 constant IC0x = 17908967629137052474112707496771758069322926085845015877922295002210990593304;
-    uint256 constant IC0y = 6383432980722921245980814464336880189669518810415631731311068271009200302026;
-    
-    uint256 constant IC1x = 1868911144786195980344314843465071030593505744917955591036688774879590238260;
-    uint256 constant IC1y = 19547389766187324141997638990895875380087036691764223886503999972786274818899;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }
diff --git a/contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol b/contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol
deleted file mode 100644
index 943635de..00000000
--- a/contracts/contracts/Verifier_dsc_rsapss_65537_sha256_2048.sol
+++ /dev/null
@@ -1,170 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_rsapss_65537_sha256_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 20750944040948293205235129837742665427980043253477347763135181580562864349782;
-    uint256 constant deltax2 = 19367007417304140595061814079021478596807088160740552708200765314130122361335;
-    uint256 constant deltay1 = 911205225690218878343339420436218110533574738192851546631473890561034124030;
-    uint256 constant deltay2 = 416799359668785031723065015671374385730091113859895605601821385687401014957;
-
-    
-    uint256 constant IC0x = 13946727458753698521402680377851722875067923384544948169783174191777177836447;
-    uint256 constant IC0y = 17849985628751165738408684253469034595472506936304780452870137032421959837082;
-    
-    uint256 constant IC1x = 9352428158600912067827704154087204016598570278103426164464615448114987091082;
-    uint256 constant IC1y = 19368944846597396863646034683545316739262021024043472849450581191116833574259;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }
diff --git a/contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol b/contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol
deleted file mode 100644
index e03b75a8..00000000
--- a/contracts/contracts/verifiers/disclose/Verifier_vc_and_disclose.sol
+++ /dev/null
@@ -1,275 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_vc_and_disclose {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 17414664872893519830503133087831113966898464613172259182120645460266886438539;
-    uint256 constant deltax2 = 17445258621513904484076939439365293726203186253030158219187200821865161670097;
-    uint256 constant deltay1 = 5213039550532744829449049599799107763468819757329084510013742838292370949828;
-    uint256 constant deltay2 = 15869132183345070916910982820810244002100961039851502709137820952731786036518;
-
-    
-    uint256 constant IC0x = 11699064754201195007398527350253348403151481002046977275974914515794556464907;
-    uint256 constant IC0y = 8377098824516723042209547366307545575336194904666442740719435968971891137137;
-    
-    uint256 constant IC1x = 15022578671217433728263017879847504938124709144805899886585104521700250021138;
-    uint256 constant IC1y = 7439374227934829324841183186890967124081563506556263992139697902117577630383;
-    
-    uint256 constant IC2x = 8719884923846896418670370483026242120279461454392494350543596555692392150751;
-    uint256 constant IC2y = 1915572466121040401254047597591235959434056701873531529685278614032487740057;
-    
-    uint256 constant IC3x = 15854458635547661044046209019901121787893952481692645870771021335496255904066;
-    uint256 constant IC3y = 18580362195513971727529458597180322208793324937796157274539580854125510824273;
-    
-    uint256 constant IC4x = 20197620246128797797969231334172536167724314393789981313273934960930874757904;
-    uint256 constant IC4y = 8652383402530547452977109949475477447090780660216084329098279248059527858257;
-    
-    uint256 constant IC5x = 6136418035854024647800871603208064108329169082713292338157990550507679741373;
-    uint256 constant IC5y = 4148249731111469783390189175626927778451683234448732196893033887074109584641;
-    
-    uint256 constant IC6x = 435016271093619026896979316149581362925836421109084185028857731123245432006;
-    uint256 constant IC6y = 21254951437721821548232352310541329777023953579777485090776415227787346519751;
-    
-    uint256 constant IC7x = 21278075374621156162040667851377496500311461883308769905293308585207243513686;
-    uint256 constant IC7y = 12203663506086881329872300647846774063295289884666082497820328056490027198813;
-    
-    uint256 constant IC8x = 16308483425091511705934563714250777026234740651509189582674872217820098595375;
-    uint256 constant IC8y = 7831547100064998764922162707495490598633878334974466872347123357740110689244;
-    
-    uint256 constant IC9x = 3291127262603144718778205947439511714981876162713868160237600958297179548397;
-    uint256 constant IC9y = 21485037857784329908791414402133986495597755287969373075934534732305491839766;
-    
-    uint256 constant IC10x = 21016409257036220162904188391746628812174550025367627914783879782321883872463;
-    uint256 constant IC10y = 771625434822550883448227440257963423499310868732489728802518320854402128338;
-    
-    uint256 constant IC11x = 848677157837511141352835832315266404476623536713045891337491496271705963639;
-    uint256 constant IC11y = 8217347855861380271136078798483880852994161288399697316508954130226938484979;
-    
-    uint256 constant IC12x = 7950645217739479484822823131266057021165813197226380213090258700020405406040;
-    uint256 constant IC12y = 21115671325929956654785783064024579377805406512650003241388844210050677251719;
-    
-    uint256 constant IC13x = 3626770947109436638554139078198740121299601968895373800820851494276106181151;
-    uint256 constant IC13y = 1231434625641659068142386110297841563481701042171599336083256459050627128218;
-    
-    uint256 constant IC14x = 16049947947771356656284191511201202183176568879064579206986716057573639688339;
-    uint256 constant IC14y = 6480470373974113105161133752760352489238403926514542525269014451361964382448;
-    
-    uint256 constant IC15x = 16974167980812170374822233712683695773735295177444364620936821746333456881288;
-    uint256 constant IC15y = 8122261017527118496247636440450416615732682768376367625137811781672190179076;
-    
-    uint256 constant IC16x = 4370481621955946039258820475154973643976715870021068098944543782894438093187;
-    uint256 constant IC16y = 9625487063950556055947770382866627694768814221480630062831377989311939157072;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[16] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-                g1_mulAccC(_pVk, IC3x, IC3y, calldataload(add(pubSignals, 64)))
-                
-                g1_mulAccC(_pVk, IC4x, IC4y, calldataload(add(pubSignals, 96)))
-                
-                g1_mulAccC(_pVk, IC5x, IC5y, calldataload(add(pubSignals, 128)))
-                
-                g1_mulAccC(_pVk, IC6x, IC6y, calldataload(add(pubSignals, 160)))
-                
-                g1_mulAccC(_pVk, IC7x, IC7y, calldataload(add(pubSignals, 192)))
-                
-                g1_mulAccC(_pVk, IC8x, IC8y, calldataload(add(pubSignals, 224)))
-                
-                g1_mulAccC(_pVk, IC9x, IC9y, calldataload(add(pubSignals, 256)))
-                
-                g1_mulAccC(_pVk, IC10x, IC10y, calldataload(add(pubSignals, 288)))
-                
-                g1_mulAccC(_pVk, IC11x, IC11y, calldataload(add(pubSignals, 320)))
-                
-                g1_mulAccC(_pVk, IC12x, IC12y, calldataload(add(pubSignals, 352)))
-                
-                g1_mulAccC(_pVk, IC13x, IC13y, calldataload(add(pubSignals, 384)))
-                
-                g1_mulAccC(_pVk, IC14x, IC14y, calldataload(add(pubSignals, 416)))
-                
-                g1_mulAccC(_pVk, IC15x, IC15y, calldataload(add(pubSignals, 448)))
-                
-                g1_mulAccC(_pVk, IC16x, IC16y, calldataload(add(pubSignals, 480)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-            checkField(calldataload(add(_pubSignals, 96)))
-            
-            checkField(calldataload(add(_pubSignals, 128)))
-            
-            checkField(calldataload(add(_pubSignals, 160)))
-            
-            checkField(calldataload(add(_pubSignals, 192)))
-            
-            checkField(calldataload(add(_pubSignals, 224)))
-            
-            checkField(calldataload(add(_pubSignals, 256)))
-            
-            checkField(calldataload(add(_pubSignals, 288)))
-            
-            checkField(calldataload(add(_pubSignals, 320)))
-            
-            checkField(calldataload(add(_pubSignals, 352)))
-            
-            checkField(calldataload(add(_pubSignals, 384)))
-            
-            checkField(calldataload(add(_pubSignals, 416)))
-            
-            checkField(calldataload(add(_pubSignals, 448)))
-            
-            checkField(calldataload(add(_pubSignals, 480)))
-            
-            checkField(calldataload(add(_pubSignals, 512)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }

From fb77493b2c4fbeac8e0f414404ac03e2d7a3a6f6 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Tue, 8 Oct 2024 02:47:36 +0900
Subject: [PATCH 08/10] change circuit list for build_disclose

---
 circuits/scripts/build_disclose_circuit.sh | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/circuits/scripts/build_disclose_circuit.sh b/circuits/scripts/build_disclose_circuit.sh
index 79a2631b..a164d12f 100755
--- a/circuits/scripts/build_disclose_circuit.sh
+++ b/circuits/scripts/build_disclose_circuit.sh
@@ -35,9 +35,6 @@ build_circuit() {
 # set build_flag to false if you want to skip the build
 CIRCUITS=(
     "vc_and_disclose:disclose:20:true"
-    "disclose:disclose:20:false"
-    "proveCountryIsNotInList:disclose:20:false"
-    "verify_commitment:disclose:22:false"
 )
 
 TOTAL_START_TIME=$(date +%s)

From bfb0a42b4b8b9a10a8c5ef936340f3630881b924 Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Tue, 8 Oct 2024 02:49:32 +0900
Subject: [PATCH 09/10] delete all dsc 2048

---
 .../instances/dsc_rsa_65537_sha1_2048.circom  |   4 -
 .../dsc_rsa_65537_sha256_2048.circom          |   5 -
 .../dsc_rsapss_65537_sha256_2048.circom       |   4 -
 circuits/scripts/build_dsc_2048_circuits.sh   |  71 -------
 .../contracts/Verifier_dsc_sha1_rsa_2048.sol  | 177 ------------------
 .../Verifier_dsc_sha256_rsa_2048.sol          | 177 ------------------
 .../Verifier_dsc_sha256_rsapss_2048.sol       | 177 ------------------
 7 files changed, 615 deletions(-)
 delete mode 100644 circuits/circuits/dsc/instances/dsc_rsa_65537_sha1_2048.circom
 delete mode 100644 circuits/circuits/dsc/instances/dsc_rsa_65537_sha256_2048.circom
 delete mode 100644 circuits/circuits/dsc/instances/dsc_rsapss_65537_sha256_2048.circom
 delete mode 100755 circuits/scripts/build_dsc_2048_circuits.sh
 delete mode 100644 contracts/contracts/Verifier_dsc_sha1_rsa_2048.sol
 delete mode 100644 contracts/contracts/Verifier_dsc_sha256_rsa_2048.sol
 delete mode 100644 contracts/contracts/Verifier_dsc_sha256_rsapss_2048.sol

diff --git a/circuits/circuits/dsc/instances/dsc_rsa_65537_sha1_2048.circom b/circuits/circuits/dsc/instances/dsc_rsa_65537_sha1_2048.circom
deleted file mode 100644
index 16476e05..00000000
--- a/circuits/circuits/dsc/instances/dsc_rsa_65537_sha1_2048.circom
+++ /dev/null
@@ -1,4 +0,0 @@
-pragma circom 2.1.9;
-include "../openpassport_dsc.circom";
-
-component main = OPENPASSPORT_DSC(3, 64, 32, 64, 32, 960, 256, 12);
diff --git a/circuits/circuits/dsc/instances/dsc_rsa_65537_sha256_2048.circom b/circuits/circuits/dsc/instances/dsc_rsa_65537_sha256_2048.circom
deleted file mode 100644
index f232ebf5..00000000
--- a/circuits/circuits/dsc/instances/dsc_rsa_65537_sha256_2048.circom
+++ /dev/null
@@ -1,5 +0,0 @@
-pragma circom 2.1.9;
-
-include "../openpassport_dsc.circom";
-
-component main = OPENPASSPORT_DSC(1, 64, 32, 120, 35, 1664, 256, 12);
\ No newline at end of file
diff --git a/circuits/circuits/dsc/instances/dsc_rsapss_65537_sha256_2048.circom b/circuits/circuits/dsc/instances/dsc_rsapss_65537_sha256_2048.circom
deleted file mode 100644
index e906e77e..00000000
--- a/circuits/circuits/dsc/instances/dsc_rsapss_65537_sha256_2048.circom
+++ /dev/null
@@ -1,4 +0,0 @@
-pragma circom 2.1.9;
-include "../openpassport_dsc.circom";
-
-component main = OPENPASSPORT_DSC(4, 64, 32, 64, 32, 960, 256, 12);
diff --git a/circuits/scripts/build_dsc_2048_circuits.sh b/circuits/scripts/build_dsc_2048_circuits.sh
deleted file mode 100755
index fb29a067..00000000
--- a/circuits/scripts/build_dsc_2048_circuits.sh
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/bin/bash
-
-# Record the start time
-TOTAL_START_TIME=$(date +%s)
-
-mkdir -p build
-cd build
-if [ ! -f powersOfTau28_hez_final_20.ptau ]; then
-    echo -e "\033[34mDownload power of tau....\033[0m"
-    wget https://hermez.s3-eu-west-1.amazonaws.com/powersOfTau28_hez_final_20.ptau
-    echo -e "\033[32mFinished download!\033[0m"
-else 
-    echo -e "\033[90mPowers of tau file already downloaded\033[0m"
-fi
-cd ..
-
-build_circuit() {
-    local CIRCUIT_NAME=$1
-    local START_TIME=$(date +%s)
-
-    echo -e "\033[34mcompiling circuit: $CIRCUIT_NAME\033[0m"
-    mkdir -p ./build/dsc/${CIRCUIT_NAME}/
-    circom circuits/dsc/instances/${CIRCUIT_NAME}.circom -l node_modules -l ./node_modules/@zk-kit/binary-merkle-root.circom/src -l ./node_modules/circomlib/circuits --r1cs --O1 --wasm -c --output build/dsc/${CIRCUIT_NAME}/
-
-    echo -e "\033[34mbuilding zkey\033[0m"
-    yarn snarkjs groth16 setup build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.r1cs build/powersOfTau28_hez_final_22.ptau build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey
-
-    if command -v openssl &> /dev/null
-    then
-        RAND_STR=$(openssl rand -hex 64)
-    else
-        RAND_STR="random text"
-    fi
-
-    echo -e "\033[34mbuilding vkey\033[0m"
-    yarn snarkjs zkey contribute build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey -e="random text"
-    yarn snarkjs zkey export verificationkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_vkey.json
-
-    yarn snarkjs zkey export solidityverifier build/dsc/${CIRCUIT_NAME}/${CIRCUIT_NAME}_final.zkey build/dsc/Verifier_${CIRCUIT_NAME}.sol
-    sed -i '' "s/Groth16Verifier/Verifier_${CIRCUIT_NAME}/g" build/dsc/Verifier_${CIRCUIT_NAME}.sol
-    mkdir -p ../contracts/contracts/local/dsc/
-    cp build/dsc/Verifier_${CIRCUIT_NAME}.sol ../contracts/contracts/local/dsc/Verifier_${CIRCUIT_NAME}.sol
-    echo -e "\033[34mcopied Verifier_${CIRCUIT_NAME}.sol to contracts\033[0m"
-
-    echo -e "\033[32mBuild of $CIRCUIT_NAME completed in $(($(date +%s) - START_TIME)) seconds\033[0m"
-
-    echo "file sizes:"
-    echo -e "\033[34mSize of ${CIRCUIT_NAME}.r1cs: $(wc -c <build/${CIRCUIT_NAME}.r1cs) bytes\033[0m"
-    echo -e "\033[34mSize of ${CIRCUIT_NAME}.wasm: $(wc -c <build/${CIRCUIT_NAME}_js/${CIRCUIT_NAME}.wasm) bytes\033[0m"
-    echo -e "\033[34mSize of ${CIRCUIT_NAME}_final.zkey: $(wc -c <build/${CIRCUIT_NAME}_final.zkey) bytes\033[0m"
-}
-
-# Define circuits and their deployment flags
-# name:deploy_flag
-CIRCUITS=(
-    "dsc_rsapss_65537_sha256_2048:false"
-    "dsc_rsa_65537_sha256_2048:true"
-    "dsc_rsa_65537_sha1_2048:false"
-)
-
-for circuit in "${CIRCUITS[@]}"; do
-    IFS=':' read -r CIRCUIT_NAME DEPLOY_FLAG <<< "$circuit"
-    if [ "$DEPLOY_FLAG" = "true" ]; then
-        echo -e "\033[34mBuilding circuit $CIRCUIT_NAME\033[0m"
-        build_circuit "$CIRCUIT_NAME"
-    else
-        echo -e "\033[90mSkipping build for $CIRCUIT_NAME\033[0m"
-    fi
-done
-
-echo -e "\033[32mTotal build completed in $(($(date +%s) - TOTAL_START_TIME)) seconds\033[0m"
\ No newline at end of file
diff --git a/contracts/contracts/Verifier_dsc_sha1_rsa_2048.sol b/contracts/contracts/Verifier_dsc_sha1_rsa_2048.sol
deleted file mode 100644
index 14ad18ef..00000000
--- a/contracts/contracts/Verifier_dsc_sha1_rsa_2048.sol
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_sha1_rsa_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 7430317108417703434372166794917187399554563629726410869171357915848086186466;
-    uint256 constant deltax2 = 19826388779896184010690202825483434764784333075120886307143470704008085111947;
-    uint256 constant deltay1 = 9154035024400062177217433795058622634427319727778700630309202612913706268399;
-    uint256 constant deltay2 = 21630179816418696841358225700326094050554890679936805812923704081130539368363;
-
-    
-    uint256 constant IC0x = 1831187731753427599498427469993070156364209280093640485240081592834524392468;
-    uint256 constant IC0y = 12050829256101574777474042248973136015751295174251031684640298540412975356077;
-    
-    uint256 constant IC1x = 15989250193192853953023955469038227095527618030821031659456209486050774261149;
-    uint256 constant IC1y = 19140815564022393725535648116464535684099604482394195607409159146820730282942;
-    
-    uint256 constant IC2x = 21555315424520171925328851084937979380671543637385698302220842793631816728183;
-    uint256 constant IC2y = 10414306106725467828220940647025160904856936048616324661714507243150024800403;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }
diff --git a/contracts/contracts/Verifier_dsc_sha256_rsa_2048.sol b/contracts/contracts/Verifier_dsc_sha256_rsa_2048.sol
deleted file mode 100644
index c7215e90..00000000
--- a/contracts/contracts/Verifier_dsc_sha256_rsa_2048.sol
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_sha256_rsa_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 10789699189802565503151410727523641117115314518647120572216097844248906379150;
-    uint256 constant deltax2 = 16666625715578834288009243693844339443049374518433194257623940944163988265395;
-    uint256 constant deltay1 = 5439536988044871326851634984289103110844569091340684053005795248561130271175;
-    uint256 constant deltay2 = 8938422785678649026868363329738732937627617012781015106661346383383684302795;
-
-    
-    uint256 constant IC0x = 8663909813730969695050901606735915443858261088173146965807918849094360759038;
-    uint256 constant IC0y = 6516840185931395389595849929543854800519438291840271040132167678505860602093;
-    
-    uint256 constant IC1x = 14347577667782826978699222586871274911031776174228003720381494632052679830813;
-    uint256 constant IC1y = 18782683358856120780455017242604555883274038589186701898217258776271016998602;
-    
-    uint256 constant IC2x = 5294494141831465394490786638500885143294697619035859501642187291794277137345;
-    uint256 constant IC2y = 67899337919533090040558324465164899011547023027876223983477868216280040814;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }
diff --git a/contracts/contracts/Verifier_dsc_sha256_rsapss_2048.sol b/contracts/contracts/Verifier_dsc_sha256_rsapss_2048.sol
deleted file mode 100644
index 6e4ffede..00000000
--- a/contracts/contracts/Verifier_dsc_sha256_rsapss_2048.sol
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_sha256_rsapss_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 18554310492392591676712582128838341835005924690711103884443707087300621489353;
-    uint256 constant deltax2 = 18601898599795148781556521129902163955307240481841048539045099403363208697265;
-    uint256 constant deltay1 = 3370744082220903501534492582354666495153084707875173458840002580755569024989;
-    uint256 constant deltay2 = 8964305547332510298822000047894858021807800763626576504695238395663847461595;
-
-    
-    uint256 constant IC0x = 11223726382902143074656034322403878698578062273836049761923160711697238928012;
-    uint256 constant IC0y = 11854539887562035595667047433241240072109196025089427592003938316087287157832;
-    
-    uint256 constant IC1x = 14225430451078657905373564833774900134131710417967612864430022348567408748517;
-    uint256 constant IC1y = 6514408194298760325517351538109990379165223555664897893408597434102056053920;
-    
-    uint256 constant IC2x = 8300252733008244838222928481751855521950685809556613151339139674935471314924;
-    uint256 constant IC2y = 18943079161101428205617834160653232136488930194714498593950700495113057494753;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }

From 038b76a23499c24ed1b6001603517c30246df24b Mon Sep 17 00:00:00 2001
From: motemotech <i.am.nicoshark@gmail.com>
Date: Tue, 8 Oct 2024 02:51:35 +0900
Subject: [PATCH 10/10] delte dsc 2048 instances after merge dev

---
 .../dsc/Verifier_dsc_sha1_rsa_2048.sol        | 177 ------------------
 .../dsc/Verifier_dsc_sha256_rsa_2048.sol      | 177 ------------------
 .../dsc/Verifier_dsc_sha256_rsapss_2048.sol   | 177 ------------------
 3 files changed, 531 deletions(-)
 delete mode 100644 contracts/contracts/verifiers/dsc/Verifier_dsc_sha1_rsa_2048.sol
 delete mode 100644 contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsa_2048.sol
 delete mode 100644 contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsapss_2048.sol

diff --git a/contracts/contracts/verifiers/dsc/Verifier_dsc_sha1_rsa_2048.sol b/contracts/contracts/verifiers/dsc/Verifier_dsc_sha1_rsa_2048.sol
deleted file mode 100644
index 14ad18ef..00000000
--- a/contracts/contracts/verifiers/dsc/Verifier_dsc_sha1_rsa_2048.sol
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_sha1_rsa_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 7430317108417703434372166794917187399554563629726410869171357915848086186466;
-    uint256 constant deltax2 = 19826388779896184010690202825483434764784333075120886307143470704008085111947;
-    uint256 constant deltay1 = 9154035024400062177217433795058622634427319727778700630309202612913706268399;
-    uint256 constant deltay2 = 21630179816418696841358225700326094050554890679936805812923704081130539368363;
-
-    
-    uint256 constant IC0x = 1831187731753427599498427469993070156364209280093640485240081592834524392468;
-    uint256 constant IC0y = 12050829256101574777474042248973136015751295174251031684640298540412975356077;
-    
-    uint256 constant IC1x = 15989250193192853953023955469038227095527618030821031659456209486050774261149;
-    uint256 constant IC1y = 19140815564022393725535648116464535684099604482394195607409159146820730282942;
-    
-    uint256 constant IC2x = 21555315424520171925328851084937979380671543637385698302220842793631816728183;
-    uint256 constant IC2y = 10414306106725467828220940647025160904856936048616324661714507243150024800403;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }
diff --git a/contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsa_2048.sol b/contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsa_2048.sol
deleted file mode 100644
index c7215e90..00000000
--- a/contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsa_2048.sol
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_sha256_rsa_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 10789699189802565503151410727523641117115314518647120572216097844248906379150;
-    uint256 constant deltax2 = 16666625715578834288009243693844339443049374518433194257623940944163988265395;
-    uint256 constant deltay1 = 5439536988044871326851634984289103110844569091340684053005795248561130271175;
-    uint256 constant deltay2 = 8938422785678649026868363329738732937627617012781015106661346383383684302795;
-
-    
-    uint256 constant IC0x = 8663909813730969695050901606735915443858261088173146965807918849094360759038;
-    uint256 constant IC0y = 6516840185931395389595849929543854800519438291840271040132167678505860602093;
-    
-    uint256 constant IC1x = 14347577667782826978699222586871274911031776174228003720381494632052679830813;
-    uint256 constant IC1y = 18782683358856120780455017242604555883274038589186701898217258776271016998602;
-    
-    uint256 constant IC2x = 5294494141831465394490786638500885143294697619035859501642187291794277137345;
-    uint256 constant IC2y = 67899337919533090040558324465164899011547023027876223983477868216280040814;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }
diff --git a/contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsapss_2048.sol b/contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsapss_2048.sol
deleted file mode 100644
index 6e4ffede..00000000
--- a/contracts/contracts/verifiers/dsc/Verifier_dsc_sha256_rsapss_2048.sol
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-/*
-    Copyright 2021 0KIMS association.
-
-    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
-
-    snarkJS is a free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    snarkJS is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
-    License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
-*/
-
-pragma solidity >=0.7.0 <0.9.0;
-
-contract Verifier_dsc_sha256_rsapss_2048 {
-    // Scalar field size
-    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
-    // Base field size
-    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
-
-    // Verification Key data
-    uint256 constant alphax  = 20491192805390485299153009773594534940189261866228447918068658471970481763042;
-    uint256 constant alphay  = 9383485363053290200918347156157836566562967994039712273449902621266178545958;
-    uint256 constant betax1  = 4252822878758300859123897981450591353533073413197771768651442665752259397132;
-    uint256 constant betax2  = 6375614351688725206403948262868962793625744043794305715222011528459656738731;
-    uint256 constant betay1  = 21847035105528745403288232691147584728191162732299865338377159692350059136679;
-    uint256 constant betay2  = 10505242626370262277552901082094356697409835680220590971873171140371331206856;
-    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
-    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
-    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
-    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 18554310492392591676712582128838341835005924690711103884443707087300621489353;
-    uint256 constant deltax2 = 18601898599795148781556521129902163955307240481841048539045099403363208697265;
-    uint256 constant deltay1 = 3370744082220903501534492582354666495153084707875173458840002580755569024989;
-    uint256 constant deltay2 = 8964305547332510298822000047894858021807800763626576504695238395663847461595;
-
-    
-    uint256 constant IC0x = 11223726382902143074656034322403878698578062273836049761923160711697238928012;
-    uint256 constant IC0y = 11854539887562035595667047433241240072109196025089427592003938316087287157832;
-    
-    uint256 constant IC1x = 14225430451078657905373564833774900134131710417967612864430022348567408748517;
-    uint256 constant IC1y = 6514408194298760325517351538109990379165223555664897893408597434102056053920;
-    
-    uint256 constant IC2x = 8300252733008244838222928481751855521950685809556613151339139674935471314924;
-    uint256 constant IC2y = 18943079161101428205617834160653232136488930194714498593950700495113057494753;
-    
- 
-    // Memory data
-    uint16 constant pVk = 0;
-    uint16 constant pPairing = 128;
-
-    uint16 constant pLastMem = 896;
-
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
-        assembly {
-            function checkField(v) {
-                if iszero(lt(v, q)) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-            
-            // G1 function to multiply a G1 value(x,y) to value in an address
-            function g1_mulAccC(pR, x, y, s) {
-                let success
-                let mIn := mload(0x40)
-                mstore(mIn, x)
-                mstore(add(mIn, 32), y)
-                mstore(add(mIn, 64), s)
-
-                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-
-                mstore(add(mIn, 64), mload(pR))
-                mstore(add(mIn, 96), mload(add(pR, 32)))
-
-                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
-
-                if iszero(success) {
-                    mstore(0, 0)
-                    return(0, 0x20)
-                }
-            }
-
-            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
-                let _pPairing := add(pMem, pPairing)
-                let _pVk := add(pMem, pVk)
-
-                mstore(_pVk, IC0x)
-                mstore(add(_pVk, 32), IC0y)
-
-                // Compute the linear combination vk_x
-                
-                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
-                
-                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
-                
-
-                // -A
-                mstore(_pPairing, calldataload(pA))
-                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
-
-                // B
-                mstore(add(_pPairing, 64), calldataload(pB))
-                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
-                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
-                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
-
-                // alpha1
-                mstore(add(_pPairing, 192), alphax)
-                mstore(add(_pPairing, 224), alphay)
-
-                // beta2
-                mstore(add(_pPairing, 256), betax1)
-                mstore(add(_pPairing, 288), betax2)
-                mstore(add(_pPairing, 320), betay1)
-                mstore(add(_pPairing, 352), betay2)
-
-                // vk_x
-                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
-                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
-
-
-                // gamma2
-                mstore(add(_pPairing, 448), gammax1)
-                mstore(add(_pPairing, 480), gammax2)
-                mstore(add(_pPairing, 512), gammay1)
-                mstore(add(_pPairing, 544), gammay2)
-
-                // C
-                mstore(add(_pPairing, 576), calldataload(pC))
-                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
-
-                // delta2
-                mstore(add(_pPairing, 640), deltax1)
-                mstore(add(_pPairing, 672), deltax2)
-                mstore(add(_pPairing, 704), deltay1)
-                mstore(add(_pPairing, 736), deltay2)
-
-
-                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
-
-                isOk := and(success, mload(_pPairing))
-            }
-
-            let pMem := mload(0x40)
-            mstore(0x40, add(pMem, pLastMem))
-
-            // Validate that all evaluations ∈ F
-            
-            checkField(calldataload(add(_pubSignals, 0)))
-            
-            checkField(calldataload(add(_pubSignals, 32)))
-            
-            checkField(calldataload(add(_pubSignals, 64)))
-            
-
-            // Validate all evaluations
-            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
-
-            mstore(0, isValid)
-             return(0, 0x20)
-         }
-     }
- }