zkjson 0.6.0 → 1.0.2

package/solidity/contracts/verifiers/verifier_json.sol

@@ -0,0 +1,261 @@
+// 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 Groth16VerifierJSON {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 20906723375066628996538723964948705883807515490851236717549543933647949219571;
+    uint256 constant alphay  = 16603277405602064515576336929405274585704793668006611444340674010517699111175;
+    uint256 constant betax1  = 15094144295718056060696456976805274960280819890173699163580614297205641683890;
+    uint256 constant betax2  = 2598197794696234583089212408001367512889853689394097760090270035862816362448;
+    uint256 constant betay1  = 13019389669452630605176375079598340867413494236340581417103700533129069013294;
+    uint256 constant betay2  = 17948608722772603517072567060031950359342932415845723852078363636578090462964;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 10548989649020101460514539324030972308502034681633392883991961616863130637984;
+    uint256 constant deltax2 = 1049946570122174039975801346728261460931086847141295177952236227197145479746;
+    uint256 constant deltay1 = 10558381744179704646192748283236903784158982943346653783344902335722321321384;
+    uint256 constant deltay2 = 16748276816739890599042583608461502899144793788720809401511640542800930620065;
+
+    
+    uint256 constant IC0x = 11086791052709537593958527982551466373543557342479473456486918346706557110272;
+    uint256 constant IC0y = 20506728735254563637401848289764804706365355653222631223947955738675551382105;
+    
+    uint256 constant IC1x = 3395672018504856885331557568801382430991065622809977080049087938633695466505;
+    uint256 constant IC1y = 16008515660025396265007279223380117478922266924915694760300639683710667540804;
+    
+    uint256 constant IC2x = 21765086794018723313508040688349754864858333265049520578918793850946099000275;
+    uint256 constant IC2y = 697811386339903182398036069234656900767187661360875928460814734795207770242;
+    
+    uint256 constant IC3x = 19890134840469468860269808836413274874961102551504281644286795822862783578836;
+    uint256 constant IC3y = 10501563686653873312925081348712045837799559277882754134863746661191456585317;
+    
+    uint256 constant IC4x = 3369539760301949842926296294765952701286437018123521538030683232199073077793;
+    uint256 constant IC4y = 17029305206701174018920590641604979023986372135961726666915339433517762654894;
+    
+    uint256 constant IC5x = 16249858468384073197585049724261300836640451596079332252974671216468387477562;
+    uint256 constant IC5y = 15430518669979717234332245816406403303816581724709051740811390921375347110404;
+    
+    uint256 constant IC6x = 15005432332128787752647304265070458721246744260154464921566645180007742802279;
+    uint256 constant IC6y = 12228853074973908182958795852882093001137862796451033278357411806506635324421;
+    
+    uint256 constant IC7x = 8279149102391716348028737479566814742618645832848275208331642895717107868296;
+    uint256 constant IC7y = 9028245630419080537816021983399031211599915437683007034212436702559232452386;
+    
+    uint256 constant IC8x = 9920315178591554201395269399878868095438996004668427910727172420497691574268;
+    uint256 constant IC8y = 13977539708344722958417991918934496531835259337681036150638988886470196226252;
+    
+    uint256 constant IC9x = 64865284880675837338119066159408029670824664912895548295809933993597129855;
+    uint256 constant IC9y = 16596614162936398597796948615700133880646516840294055167278997135786201638865;
+    
+    uint256 constant IC10x = 20041216278333661355857000399562164892538427870735609885548447419114215265900;
+    uint256 constant IC10y = 7188425125877597681508434156838946918685965411196380330181753494345911319474;
+    
+    uint256 constant IC11x = 10344667596317540812042141319424780533548696928275174590606414302423871416439;
+    uint256 constant IC11y = 15177912543756596934916481207669485500307163540835148656062032711878901603531;
+    
+    uint256 constant IC12x = 3003572233500184455318954446784006239696026573012811847295348627074111281539;
+    uint256 constant IC12y = 6485361686957307324235352983357156310358934769793375149333110905137006337248;
+    
+    uint256 constant IC13x = 2025484288051762304170760878169695013364214111997466862551524207031601382631;
+    uint256 constant IC13y = 7038960739366138059493181524660940249493960394838603142532679804397882049709;
+    
+    uint256 constant IC14x = 11387856957329089595489992260814785056704488293876837097183204151395206987719;
+    uint256 constant IC14y = 17844362785282169318131685916181008035618810588862118232161118858351706006467;
+    
+ 
+    // 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[14] 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)))
+                
+
+                // -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)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

package/solidity/contracts/verifiers/verifier_rollup.sol

@@ -0,0 +1,240 @@
+// 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 Groth16VerifierRU {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 8154397773694967106321908543225581308345926075547707849461770589063806208933;
+    uint256 constant alphay  = 5677108055266898448889486339855982693826760854574703967712162419621387623014;
+    uint256 constant betax1  = 4355293952982460708458173032048895255835173115891032808050720056003898803424;
+    uint256 constant betax2  = 3059800330157143526908077176335177789758447764497844662322128804304930412762;
+    uint256 constant betay1  = 12948155637479005941322226125984465377528965309571693953410360452319923301251;
+    uint256 constant betay2  = 7332222563511878888805485279601765944630172818413249156252409812683246711891;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 12826039923985305509172445548825630308307897385636638314103089050117034765807;
+    uint256 constant deltax2 = 5777316040111550683119122338100696671533578054713112313962719197468777904391;
+    uint256 constant deltay1 = 13100118653411399080908320939554734522926116642572965561618759712020115377487;
+    uint256 constant deltay2 = 4863992084126820334137644474127866316351574790993028000936897867731380377202;
+
+    
+    uint256 constant IC0x = 6270950016247133466336754274326443126017687703801742756948638236534086892047;
+    uint256 constant IC0y = 20310453393525738917452540227487036745129047678621136376195858836563533911527;
+    
+    uint256 constant IC1x = 1141343197515056438569346347535803858564689453833647046018791462772549149227;
+    uint256 constant IC1y = 16491780663163267442130703331018113562992698794258578658230547724337214632511;
+    
+    uint256 constant IC2x = 5569694830107596991306292701850289725347601942273592203980263593485643232633;
+    uint256 constant IC2y = 5496875873369182800954050214612959091907601104963709673444966250025502326758;
+    
+    uint256 constant IC3x = 856226396972901355666350894014284120170327945287396680478814592107007149805;
+    uint256 constant IC3y = 4080222902213037494283476857599202091267684100021446005131603140238216815391;
+    
+    uint256 constant IC4x = 10764306455319897189590233363611208010675243280639689255137625645138943859385;
+    uint256 constant IC4y = 19346540917500920047750697423047140511552971607568238316315807020898102730868;
+    
+    uint256 constant IC5x = 16857068565745876906748660361991141069946983257614833579471638734061485457112;
+    uint256 constant IC5y = 14632180805427053926564788976583761986580123762441719835724709161702471836981;
+    
+    uint256 constant IC6x = 12315747360356477219902572740218642460149278211574165192334271766621665438376;
+    uint256 constant IC6y = 1313234108449442273460693358644853644145068014633280121061495643296281134420;
+    
+    uint256 constant IC7x = 15252212582859770288887248094717972825568314500168925087757606041256952964029;
+    uint256 constant IC7y = 19751607759272618647644406330677066920139018206963959740625861713276025168423;
+    
+    uint256 constant IC8x = 8432690145128824085267914412714661508760195558814883868966832777728733350601;
+    uint256 constant IC8y = 20683188851611894785172396447809130386092126094512442322570355864144302756164;
+    
+    uint256 constant IC9x = 19369987132771616043793275659835942692385855791064890369063891639761686156657;
+    uint256 constant IC9y = 8426683055759400985089789088504223062497842350159798813155638560974712761643;
+    
+    uint256 constant IC10x = 20860096825664394339889589645802586392309097833727587594050802394079690409091;
+    uint256 constant IC10y = 17908147166318266417496260692526339764629505794576827802816790292654348457101;
+    
+    uint256 constant IC11x = 7111525545052173450141644018481693095722931164254044734852844952175519360375;
+    uint256 constant IC11y = 14968059451881120855243147686628983750275388350316603656458857787322628363714;
+    
+ 
+    // 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[11] 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)))
+                
+
+                // -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)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

package/solidity/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "hardhat-project",
+  "devDependencies": {
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.6",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.10",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.2",
+    "@nomicfoundation/hardhat-verify": "^2.0.3",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
+    "@nomiclabs/hardhat-etherscan": "^3.1.8",
+    "@typechain/ethers-v5": "^10.2.1",
+    "@typechain/hardhat": "^6.1.6",
+    "@types/chai": "^4.3.11",
+    "@types/mocha": "^10.0.6",
+    "chai": "4",
+    "hardhat": "^2.19.4",
+    "hardhat-gas-reporter": "^1.0.9",
+    "solidity-coverage": "^0.8.5",
+    "ts-node": "^10.9.2",
+    "typechain": "^8.3.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.0.1",
+    "snarkjs": "^0.7.2"
+  },
+  "license": "MIT"
+}

package/solidity/scripts/deploy.js

@@ -0,0 +1,33 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require("hardhat")
+
+async function main() {
+  const VerifierJSON = await hre.ethers.getContractFactory(
+    "Groth16VerifierJSON"
+  )
+  const verifierJSON = await VerifierJSON.deploy()
+  await verifierJSON.deployed()
+  console.log("verifier", verifierJSON.address)
+
+  const ZKAR = await hre.ethers.getContractFactory("ZKArweave")
+  const zkar = await ZKAR.deploy(
+    verifierJSON.address,
+    "0x078694d69426112c7df330732e28F5117B02727A"
+  )
+
+  await zkar.deployed()
+
+  console.log("zkar", zkar.address)
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch(error => {
+  console.error(error)
+  process.exitCode = 1
+})

package/solidity/test/NORU.js

@@ -0,0 +1,66 @@
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { toIndex, path, DB } = require("../../sdk")
+const { resolve } = require("path")
+const { expect } = require("chai")
+
+async function deploy() {
+  const VerifierDB = await ethers.getContractFactory("Groth16VerifierDB")
+  const verifierDB = await VerifierDB.deploy()
+
+  const NORU = await ethers.getContractFactory("NORU")
+  const noru = await NORU.deploy(verifierDB.address)
+  return { noru }
+}
+
+describe("MyRollup", function () {
+  let noru
+  this.timeout(0)
+
+  beforeEach(async () => {
+    const dep = await loadFixture(deploy)
+    noru = dep.noru
+  })
+
+  it("should verify rollup transactions", async function () {
+    const db = new DB({
+      level: 168,
+      size_path: 4,
+      size_val: 8,
+      size_json: 256,
+      size_txs: 10,
+      level_col: 8,
+      wasm: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_js/index.wasm",
+      ),
+      zkey: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_0001.zkey",
+      ),
+    })
+    await db.init()
+    const col_id = await db.addCollection()
+    const people = [{ name: "Bob", age: 5 }]
+    let txs = people.map(v => {
+      return [col_id, v.name, v]
+    })
+    for (const v of txs) await db.insert(...v)
+    const zkp = await db.genProof({
+      json: people[0],
+      col_id,
+      path: "name",
+      id: "Bob",
+    })
+
+    expect(await noru.qString(zkp)).to.eql("Bob")
+
+    const zkp2 = await db.genProof({
+      json: people[0],
+      col_id,
+      path: "age",
+      id: "Bob",
+      query: ["$gt", 3],
+    })
+    expect(await noru.qCond(zkp2.slice(13, 14), zkp2)).to.eql(true)
+  })
+})