arnaucube
/
miksi-core
mirror of https://github.com/arnaucube/miksi-core.git
1
1
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add SmartContracts test flow with 3 deposits

pull/2/head
arnaucube 4 years ago
parent
c3b5165006
commit
4b2a229bd9
5 changed files with 195 additions and 161 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -1
      circuits/deposit.circom
  2. +10
    -10
      contracts/deposit-verifier.sol
  3. +10
    -10
      contracts/withdraw-verifier.sol
  4. +1
    -0
      test/circuits/deposit.test.ts
  5. +171
    -140
      test/contracts/miksi.test.ts

+ 3
- 1
circuits/deposit.circom
View File

@ -35,6 +35,7 @@ template Deposit(nLevels) {
signal input amount; signal input amount;
signal private input secret; signal private input secret;
signal private input nullifier; signal private input nullifier;
signal private input oldKey;
signal private input siblingsOld[nLevels]; signal private input siblingsOld[nLevels];
signal private input siblingsNew[nLevels]; signal private input siblingsNew[nLevels];
signal input rootOld; signal input rootOld;
@ -61,7 +62,8 @@ template Deposit(nLevels) {
for (var i=0; i<nLevels; i++) { for (var i=0; i<nLevels; i++) {
smtOld.siblings[i] <== siblingsOld[i]; smtOld.siblings[i] <== siblingsOld[i];
} }
smtOld.oldKey <== 1;
/* smtOld.oldKey <== 1; */
smtOld.oldKey <== oldKey;
smtOld.oldValue <== 0; smtOld.oldValue <== 0;
smtOld.isOld0 <== 0; smtOld.isOld0 <== 0;
smtOld.key <== hash.out; smtOld.key <== hash.out;

+ 10
- 10
contracts/deposit-verifier.sol
View File

@ -174,17 +174,17 @@ contract DepositVerifier {
DepositPairing.G1Point C; DepositPairing.G1Point C;
} }
function verifyingKey() internal pure returns (VerifyingKey memory vk) { function verifyingKey() internal pure returns (VerifyingKey memory vk) {
vk.alfa1 = DepositPairing.G1Point(6065483927189198444682905308325000951246257469152828409806284077885133249739,1990028136278429445518006524392551345128366216259976542235494496185998414912);
vk.beta2 = DepositPairing.G2Point([9264834971516100639871261194399140486562775525051734782501439416023479225391,5162939940530468633865380033187237384667734222189925309044161499791615506375], [489842918389814266437556836747821551396498728159626876991041866052737351566,17404338846724633734949676544603763660215742965552403738436754194013115104404]);
vk.gamma2 = DepositPairing.G2Point([3816215622778176681699259539967429072196356640030859639514936270238959698219,236252540670993251838452790992568688843063704489202689719563908537636316738], [16303927206925158108103606822067759987757608633916911445237700431553497043690,12668251450800271509987871102239080189070836108197224795008764353502619814964]);
vk.delta2 = DepositPairing.G2Point([7734429969653199634693555623385094248569235945832114705562051837787377060806,7566151879414510490108686246718202304489426052757532512550882626288777754959], [17950916274576625246093655071576904884259522730229572495774693174259627926717,15060426040589607858464359473475255324856592450467055295537458068465028256933]);
vk.alfa1 = DepositPairing.G1Point(4690052268710270598869542532809702456418003799694536273077130369652196429884,9145902013599810527210227446448286424172036724970647907168421870847502009945);
vk.beta2 = DepositPairing.G2Point([16623062689690044255750716956401317560821762623856422123246403067057225130588,14652078637219990978821431784894112719594629514313306953371073983618015546541], [676307836452309210538606902645077301940331422390550491696691282441239090551,10369757414475454684684292675796821047567632748417978318178776038061059658326]);
vk.gamma2 = DepositPairing.G2Point([16528273881363574239250709218131920578661276173856341283262670072792844980215,6787263438752395682957935213403119833234411728635969992478064476167401704867], [5274450027585795927175443590954483941244906290165165924583130738506736130942,3392062216862930269651390569850019803754187174311810728530683507098775212357]);
vk.delta2 = DepositPairing.G2Point([17494603128862092548460623189930936969297925345032047648552416238816792961152,10402239940545833330287339048137499178728329705094695706126321196019762386747], [6175570631583630130350739728971333086849468117273142369720724145166167909214,20067049654764111179832549405286061192607773249291087398308936796066289541314]);
vk.IC = new DepositPairing.G1Point[](6); vk.IC = new DepositPairing.G1Point[](6);
vk.IC[0] = DepositPairing.G1Point(15740910832481450063917199200607757253896563901763566776712306503750389541655,7002622853975178066023339356151543160177210573049820374279694406406811606683);
vk.IC[1] = DepositPairing.G1Point(15651632245328303900076885367222245590896431851640402182626448905226427580557,17750666936414774331918745613015398412439836969964160634716436648984069791919);
vk.IC[2] = DepositPairing.G1Point(20430695676495506508861377450422139686450342947107294821941229966423680102028,14134642346581319191800114388829157260027077654897972406787486086063657679416);
vk.IC[3] = DepositPairing.G1Point(20847463192934719709544463297660864346200920891710723190222906696182133119937,18120989364581496594830515144678135218782618145865982639015727693739056183109);
vk.IC[4] = DepositPairing.G1Point(12885189407733919760194724425636212244425270670891712206493473002258558049469,11907583641464815994264125178011364350201623207761143086863586332263235489212);
vk.IC[5] = DepositPairing.G1Point(15710396156244792890296909465340259245113590590754779011653647914536045233207,3713091448502606308226556683433495935849952195712182929387849333358831559987);
vk.IC[0] = DepositPairing.G1Point(12697195619443882847721561991615544069218791667870821589914853846794238615885,18011435976524410295453245674507929643029222984348817278231712383283229915782);
vk.IC[1] = DepositPairing.G1Point(20324524778567704633470845008079551007952919835272398568401853167438653396525,8061504440558567975766943783054577602934521477527864647610640054521787242724);
vk.IC[2] = DepositPairing.G1Point(13332163378649502560807390864020561151254011879905389699984218750502394665905,4286598055677625399864995783940420134575107187974587372574457085466044561759);
vk.IC[3] = DepositPairing.G1Point(10175138903387311357088170792861518054422766016077544491949838159573444744976,16570515458939310802788756001103880353070070639900081360517205384175233432226);
vk.IC[4] = DepositPairing.G1Point(3298627468931988714290186736998190106240510584555740172431361939625148350723,10415330389886845959598036431340102923398308416032482557275534081287380793067);
vk.IC[5] = DepositPairing.G1Point(16030968253618323807449863533252146464206835591288004165377534537620304134907,6223567249648011787592835059978931866773091863735841649895374018321000148662);
} }
function verify(uint[] memory input, Proof memory proof) internal view returns (uint) { function verify(uint[] memory input, Proof memory proof) internal view returns (uint) {

+ 10
- 10
contracts/withdraw-verifier.sol
View File

@ -174,17 +174,17 @@ contract WithdrawVerifier {
WithdrawPairing.G1Point C; WithdrawPairing.G1Point C;
} }
function verifyingKey() internal pure returns (VerifyingKey memory vk) { function verifyingKey() internal pure returns (VerifyingKey memory vk) {
vk.alfa1 = WithdrawPairing.G1Point(6000897918197332766506368147052471432111990912139168143792639323668717117554,12425390154424956101354759127312889936479801351672835365540548682812480095245);
vk.beta2 = WithdrawPairing.G2Point([12995810398277449653207359598519433373340512547398516711648573639615955145427,343617895487181701521196169649006712676439974399109594954509192275962550132], [17161358293812801401457835844542021467864192455439896392380755898197601531143,7029713736223430242826003690322757881565075810973246047711502677037078502374]);
vk.gamma2 = WithdrawPairing.G2Point([4451458705618509102819397935871317286248761901894290610851650437269450341367,4727411170130069370259012444008481725824234708683616201162714031612495948731], [19293222415010534295664881991699322834609751800455409899967018063051565373785,745420935028621855676130519141412373862608212652605821057639752116562245651]);
vk.delta2 = WithdrawPairing.G2Point([4374144803633960156913542400168655607562448734674078186890371435456649285947,18059818950726521358193085349108907422220028073396980874415049690926599813200], [18613292511366130375634190418118794626384059450307359965218281303441038152855,6142273376405607153924858120972958679132506572414341818723557928185966082039]);
vk.alfa1 = WithdrawPairing.G1Point(13125964035345732513320606972223597271702849498706862906431560515196316741541,2743237172859524479647981525721821119820168209195336069832075995585988365216);
vk.beta2 = WithdrawPairing.G2Point([2669112095067980506727873345758867054347466312660021806636272987760660828849,14539491114301519973242319011485401150263667232078179655062833197913312500017], [11720061635178934637313951615051060311580364580444053837400914945552182061616,2177765169672031700082566520171740120321696910335776288543190901344722545410]);
vk.gamma2 = WithdrawPairing.G2Point([10917104788485395001839994387809646569218736354722844653893803100190554724907,7478437791943783449531717383744438552168785436031321431732103220558102742468], [14238787877319603173234096439758621306673382329766962364233031837910870237536,10502637950741476389590969419560058151857179703312600335067455738743909083958]);
vk.delta2 = WithdrawPairing.G2Point([11073954909083264728700321333863259614089048106992800121105800848198886470375,14812237089106501466576017780356417002388876842333510442550104527732748120622], [17635776349801663084503912927095921433092564181571541546104162053167176565421,27998176086381233961153068490868928492606872937787873022612510202839716507]);
vk.IC = new WithdrawPairing.G1Point[](6); vk.IC = new WithdrawPairing.G1Point[](6);
vk.IC[0] = WithdrawPairing.G1Point(18721847862304480418699947867805588529802575657037041011052498091030411101583,9568910167355731514566701497653796956835627895615164441707708470729627612263);
vk.IC[1] = WithdrawPairing.G1Point(10992751145268189991746341097903721033023715291976945698456511965931756835520,19961192492430389207692681921975764975917502670389597865899368965309694589277);
vk.IC[2] = WithdrawPairing.G1Point(21240739576686376297062566361701745917046221787464798372252058270610707408612,5312356818216485347682134231435321362864300228436464960252407654010175727066);
vk.IC[3] = WithdrawPairing.G1Point(12021960796216563791001698492379654159377101982562013928932485809042439120925,15563397276080084799646082626498117356990307894712348255140484765600785090381);
vk.IC[4] = WithdrawPairing.G1Point(3353092686593664458934514005821883140650039230269909371443918946771143324513,14956396613446673022413666390276229141175487038479075213761081413376234000704);
vk.IC[5] = WithdrawPairing.G1Point(16092225522211246726577788389583375146706125153344163393485911026516851929934,19965075922885092132859170198788412557863541723358903150696160537884812856033);
vk.IC[0] = WithdrawPairing.G1Point(7491469026033918642677753652819151318339809973344463260827293357803586754235,4395946869661103322863744384786121261968956085472500963739363200632751346458);
vk.IC[1] = WithdrawPairing.G1Point(15792971708971548807702008065816978287582873199570212151763666852711881685748,20015547917924502689826594351540769795386333462562793050625401907390132405289);
vk.IC[2] = WithdrawPairing.G1Point(793110436159598650905223468298132112327901373645402348921311553793588112899,14932167562920745456386464748315950361167693788066386103439968740538587455112);
vk.IC[3] = WithdrawPairing.G1Point(3599763262227997054360288324315679176821090066709181138105454315553755125997,4842799741086852072636969222133537228560778966327440675220863187433692844579);
vk.IC[4] = WithdrawPairing.G1Point(1332654856961752997984248173858188249144320018346121854916888456163273080288,18357171701145993355281642916301559974565034917797021528848570764297806434641);
vk.IC[5] = WithdrawPairing.G1Point(12178090359527457673534455683642890230743486788471599510120235645318440790942,14955354663406965918722091973717855430180824697349764743374253473894681342412);
} }
function verify(uint[] memory input, Proof memory proof) internal view returns (uint) { function verify(uint[] memory input, Proof memory proof) internal view returns (uint) {

+ 1
- 0
test/circuits/deposit.test.ts
View File

@ -61,6 +61,7 @@ describe("deposit test", function () {
"amount": amount, "amount": amount,
"secret": secret, "secret": secret,
"nullifier": nullifier, "nullifier": nullifier,
"oldKey": "1",
"siblingsOld": siblingsOld, "siblingsOld": siblingsOld,
"siblingsNew": siblingsNew, "siblingsNew": siblingsNew,
"rootOld": rootOld, "rootOld": rootOld,

+ 171
- 140
test/contracts/miksi.test.ts
View File

@ -13,6 +13,29 @@ const WitnessCalculatorBuilder = require("circom_runtime").WitnessCalculatorBuil
const circomlib = require("circomlib"); const circomlib = require("circomlib");
const smt = require("circomlib").smt; const smt = require("circomlib").smt;
let insVerifier;
let insMiksi;
const nLevels = 5;
const secret = ["1234567890", "987654321", "123"];
const coinCode = "0"; // refearing to ETH
const ethAmount = '1';
const amount = web3.utils.toWei(ethAmount, 'ether');
const nullifier = ["567891234", "432198765", "321"];
let commitment = [];
let tree;
let oldKey = [];
let siblingsOld = [];
let siblingsNew = [];
let rootOld = [];
let rootNew = [];
// let commitment = [];
let proof = [];
let publicSignals = [];
let commitmentsArray = [];
let u = 0;
contract("miksi", (accounts) => { contract("miksi", (accounts) => {
@ -21,27 +44,9 @@ contract("miksi", (accounts) => {
1: addr1, // used for the deposit 1: addr1, // used for the deposit
2: addr2, // used for the withdraw 2: addr2, // used for the withdraw
3: addr3, 3: addr3,
4: addr4,
} = accounts; } = accounts;
let insVerifier;
let insMiksi;
const nLevels = 5;
const secret = "1234567890";
const coinCode = "0"; // refearing to ETH
const ethAmount = '1';
const amount = web3.utils.toWei(ethAmount, 'ether');
const nullifier = "567891234";
let tree;
let siblingsOld;
let siblingsNew;
let rootOld;
let rootNew;
let commitment;
let proof;
let publicSignals;
let commitmentsArray;
before(async () => { before(async () => {
insDepositVerifier = await DepositVerifier.new(); insDepositVerifier = await DepositVerifier.new();
@ -54,35 +59,126 @@ contract("miksi", (accounts) => {
// console.log("Balance at " + addr1, web3.utils.fromWei(balance_wei, 'ether')); // console.log("Balance at " + addr1, web3.utils.fromWei(balance_wei, 'ether'));
expect(balance_wei).to.be.equal('100000000000000000000'); expect(balance_wei).to.be.equal('100000000000000000000');
tree = await smt.newMemEmptyTrie();
await tree.insert(1, 0);
await computeTree(0);
expect(rootOld[0].toString()).to.be.equal('11499909227292257605992378629333104385616480982267969744564817844870636870870');
expect(rootNew[0].toString()).to.be.equal('9328869343897770565751281504295758914771207504252217956739346620422361279598');
});
it("Make first deposit", async () => {
await makeDeposit(0, addr1);
balance_wei = await web3.eth.getBalance(addr1);
// console.log("Balance at " + addr1, web3.utils.fromWei(balance_wei, 'ether'));
// expect(balance_wei).to.be.equal('98993526980000000000');
});
it("Make second deposit", async () => {
await computeTree(1);
await makeDeposit(1, addr3);
});
it("Make 3rd deposit", async () => {
await computeTree(2);
await makeDeposit(2, addr3);
});
it("Get the commitments data", async () => {
// getCommitments data
let res = await insMiksi.getCommitments();
expect(res[0][0].toString()).to.be.equal('189025084074544266465422070282645213792582195466360448472858620722286781863');
// expect(res[1].toString()).to.be.equal('9328869343897770565751281504295758914771207504252217956739346620422361279598');
console.log(res[0]);
commitmentsArray[0] = res[0];
});
it("Rebuild the tree from sc commitments", async () => {
let treeTmp = await smt.newMemEmptyTrie();
await treeTmp.insert(1, 0);
for (let i=0; i<commitmentsArray[0].length; i++) {
await treeTmp.insert(commitmentsArray[0][i], 0);
}
expect(treeTmp.root).to.be.equal(tree.root);
});
it("Calculate witness and generate the zkProof", async () => {
await genZKProof(0, addr2);
await genZKProof(1, addr4);
await genZKProof(2, addr4);
});
it("Try to use the zkProof with another address and get revert", async () => {
// console.log("Try to reuse the zkproof and expect revert");
await truffleAssert.fails(
withdrawSC(0, addr1),
truffleAssert.ErrorType.REVERT,
"zkProof withdraw could not be verified"
);
});
it("Withdraw 1 ETH with the zkProof of the 1st deposit to addr2", async () => {
// withdraw
// console.log("Withdraw of " + ethAmount + " ETH to " + addr2);
let resW = await withdrawSC(0, addr2);
// console.log("resW", resW);
balance_wei = await web3.eth.getBalance(addr2);
// console.log("Balance at " + addr2, web3.utils.fromWei(balance_wei, 'ether'));
expect(balance_wei).to.be.equal('101000000000000000000');
});
it("Try to reuse the zkProof and get revert", async () => {
// console.log("Try to reuse the zkproof and expect revert");
await truffleAssert.fails(
withdrawSC(0, addr2),
truffleAssert.ErrorType.REVERT,
"nullifier already used"
);
balance_wei = await web3.eth.getBalance(addr2);
expect(balance_wei).to.be.equal('101000000000000000000');
});
it("Withdraw 1 ETH with the zkProof of the 2nd deposit to addr4", async () => {
let resW = await withdrawSC(1, addr4);
balance_wei = await web3.eth.getBalance(addr4);
expect(balance_wei).to.be.equal('101000000000000000000');
});
it("Withdraw 1 ETH with the zkProof of the 3rd deposit to addr4", async () => {
let resW = await withdrawSC(2, addr4);
balance_wei = await web3.eth.getBalance(addr4);
expect(balance_wei).to.be.equal('102000000000000000000');
});
});
async function computeTree(u) {
const poseidon = circomlib.poseidon.createHash(6, 8, 57); const poseidon = circomlib.poseidon.createHash(6, 8, 57);
commitment = poseidon([coinCode, amount, secret, nullifier]).toString();
commitment[u] = poseidon([coinCode, amount, secret[u], nullifier[u]]).toString();
// deposit // deposit
// add commitment into SMT // add commitment into SMT
tree = await smt.newMemEmptyTrie();
await tree.insert(1, 0);
rootOld = tree.root;
const resC = await tree.find(commitment);
rootOld[u] = tree.root;
const resC = await tree.find(commitment[u]);
assert(!resC.found); assert(!resC.found);
siblingsOld = resC.siblings;
while (siblingsOld.length < nLevels) {
siblingsOld.push("0");
oldKey[u] = "1";
if (!resC.found) {
oldKey[u] = resC.notFoundKey.toString();
}
siblingsOld[u] = resC.siblings;
while (siblingsOld[u].length < nLevels) {
siblingsOld[u].push("0");
}; };
await tree.insert(commitment, 0);
rootNew = tree.root;
await tree.insert(commitment[u], 0);
rootNew[u] = tree.root;
}
expect(rootOld.toString()).to.be.equal('11499909227292257605992378629333104385616480982267969744564817844870636870870');
expect(rootNew.toString()).to.be.equal('9328869343897770565751281504295758914771207504252217956739346620422361279598');
});
it("Make the deposit", async () => {
const resC = await tree.find(commitment);
async function makeDeposit(u, addr) {
const resC = await tree.find(commitment[u]);
assert(resC.found); assert(resC.found);
siblingsNew = resC.siblings;
while (siblingsNew.length < nLevels) {
siblingsNew.push("0");
siblingsNew[u] = resC.siblings;
while (siblingsNew[u].length < nLevels) {
siblingsNew[u].push("0");
}; };
// calculate witness // calculate witness
@ -90,13 +186,14 @@ contract("miksi", (accounts) => {
const input = unstringifyBigInts({ const input = unstringifyBigInts({
"coinCode": coinCode, "coinCode": coinCode,
"amount": amount, "amount": amount,
"secret": secret,
"nullifier": nullifier,
"siblingsOld": siblingsOld,
"siblingsNew": siblingsNew,
"rootOld": rootOld,
"rootNew": rootNew,
"commitment": commitment
"secret": secret[u],
"nullifier": nullifier[u],
"oldKey": oldKey[u],
"siblingsOld": siblingsOld[u],
"siblingsNew": siblingsNew[u],
"rootOld": rootOld[u],
"rootNew": rootNew[u],
"commitment": commitment[u]
}); });
const options = {}; const options = {};
// console.log("Calculate witness"); // console.log("Calculate witness");
@ -109,50 +206,29 @@ contract("miksi", (accounts) => {
// console.log("Generate zkSNARK proof"); // console.log("Generate zkSNARK proof");
const res = groth.genProof(provingKey, witness); const res = groth.genProof(provingKey, witness);
proof = res.proof;
publicSignals = res.publicSignals;
proof[u] = res.proof;
publicSignals[u] = res.publicSignals;
const verificationKey = unstringifyBigInts(JSON.parse(fs.readFileSync("./build/deposit-verification_key.json", "utf8"))); const verificationKey = unstringifyBigInts(JSON.parse(fs.readFileSync("./build/deposit-verification_key.json", "utf8")));
let pubI = unstringifyBigInts([coinCode, amount, rootOld.toString(), rootNew.toString(), commitment]);
let validCheck = groth.isValid(verificationKey, proof, pubI);
let pubI = unstringifyBigInts([coinCode, amount, rootOld[u].toString(), rootNew[u].toString(), commitment[u]]);
let validCheck = groth.isValid(verificationKey, proof[u], pubI);
assert(validCheck); assert(validCheck);
await insMiksi.deposit( await insMiksi.deposit(
commitment,
commitment[u],
tree.root.toString(), tree.root.toString(),
[proof.pi_a[0].toString(), proof.pi_a[1].toString()],
[proof[u].pi_a[0].toString(), proof[u].pi_a[1].toString()],
[ [
[proof.pi_b[0][1].toString(), proof.pi_b[0][0].toString()],
[proof.pi_b[1][1].toString(), proof.pi_b[1][0].toString()]
[proof[u].pi_b[0][1].toString(), proof[u].pi_b[0][0].toString()],
[proof[u].pi_b[1][1].toString(), proof[u].pi_b[1][0].toString()]
], ],
[proof.pi_c[0].toString(), proof.pi_c[1].toString()],
{from: addr1, value: amount}
[proof[u].pi_c[0].toString(), proof[u].pi_c[1].toString()],
{from: addr, value: amount}
); );
balance_wei = await web3.eth.getBalance(addr1);
// console.log("Balance at " + addr1, web3.utils.fromWei(balance_wei, 'ether'));
// expect(balance_wei).to.be.equal('98993526980000000000');
});
}
it("Get the commitments data", async () => {
// getCommitments data
let res = await insMiksi.getCommitments();
expect(res[0][0].toString()).to.be.equal('189025084074544266465422070282645213792582195466360448472858620722286781863');
expect(res[1].toString()).to.be.equal('9328869343897770565751281504295758914771207504252217956739346620422361279598');
console.log(res[0]);
commitmentsArray = res[0];
});
it("Rebuild the tree from sc commitments", async () => {
let treeTmp = await smt.newMemEmptyTrie();
await treeTmp.insert(1, 0);
for (let i=0; i<commitmentsArray.length; i++) {
await treeTmp.insert(commitmentsArray[i], 0);
}
expect(treeTmp.root).to.be.equal(tree.root);
});
it("Calculate witness and generate the zkProof", async () => {
const resC = await tree.find(commitment);
async function genZKProof(u, addr) {
const resC = await tree.find(commitment[u]);
assert(resC.found); assert(resC.found);
let siblings = resC.siblings; let siblings = resC.siblings;
while (siblings.length < nLevels) { while (siblings.length < nLevels) {
@ -165,11 +241,11 @@ contract("miksi", (accounts) => {
const input = unstringifyBigInts({ const input = unstringifyBigInts({
"coinCode": coinCode, "coinCode": coinCode,
"amount": amount, "amount": amount,
"secret": secret,
"nullifier": nullifier,
"secret": secret[u],
"nullifier": nullifier[u],
"siblings": siblings, "siblings": siblings,
"root": tree.root, "root": tree.root,
"address": addr2
"address": addr
}); });
const options = {}; const options = {};
// console.log("Calculate witness"); // console.log("Calculate witness");
@ -182,65 +258,20 @@ contract("miksi", (accounts) => {
// console.log("Generate zkSNARK proof"); // console.log("Generate zkSNARK proof");
const res = groth.genProof(provingKey, witness); const res = groth.genProof(provingKey, witness);
proof = res.proof;
publicSignals = res.publicSignals;
});
proof[u] = res.proof;
publicSignals[u] = res.publicSignals;
}
it("Try to use the zkProof with another address and get revert", async () => {
// console.log("Try to reuse the zkproof and expect revert");
await truffleAssert.fails(
insMiksi.withdraw(
addr1,
nullifier,
[proof.pi_a[0].toString(), proof.pi_a[1].toString()],
async function withdrawSC(u, addr) {
return insMiksi.withdraw(
addr,
nullifier[u],
[proof[u].pi_a[0].toString(), proof[u].pi_a[1].toString()],
[ [
[proof.pi_b[0][1].toString(), proof.pi_b[0][0].toString()],
[proof.pi_b[1][1].toString(), proof.pi_b[1][0].toString()]
[proof[u].pi_b[0][1].toString(), proof[u].pi_b[0][0].toString()],
[proof[u].pi_b[1][1].toString(), proof[u].pi_b[1][0].toString()]
], ],
[proof.pi_c[0].toString(), proof.pi_c[1].toString()]
),
truffleAssert.ErrorType.REVERT,
"zkProof withdraw could not be verified"
);
});
it("Withdraw 1 ETH with the zkProof", async () => {
// withdraw
// console.log("Withdraw of " + ethAmount + " ETH to " + addr2);
let resW = await insMiksi.withdraw(
addr2,
nullifier,
[proof.pi_a[0].toString(), proof.pi_a[1].toString()],
[
[proof.pi_b[0][1].toString(), proof.pi_b[0][0].toString()],
[proof.pi_b[1][1].toString(), proof.pi_b[1][0].toString()]
],
[proof.pi_c[0].toString(), proof.pi_c[1].toString()]
);
// console.log("resW", resW);
balance_wei = await web3.eth.getBalance(addr2);
// console.log("Balance at " + addr2, web3.utils.fromWei(balance_wei, 'ether'));
expect(balance_wei).to.be.equal('101000000000000000000');
});
[proof[u].pi_c[0].toString(), proof[u].pi_c[1].toString()]
);
}
it("Try to reuse the zkProof and get revert", async () => {
// console.log("Try to reuse the zkproof and expect revert");
await truffleAssert.fails(
insMiksi.withdraw(
addr2,
nullifier,
[proof.pi_a[0].toString(), proof.pi_a[1].toString()],
[
[proof.pi_b[0][1].toString(), proof.pi_b[0][0].toString()],
[proof.pi_b[1][1].toString(), proof.pi_b[1][0].toString()]
],
[proof.pi_c[0].toString(), proof.pi_c[1].toString()]
),
truffleAssert.ErrorType.REVERT,
"nullifier already used"
);
balance_wei = await web3.eth.getBalance(addr2);
expect(balance_wei).to.be.equal('101000000000000000000');
});
});

Write Preview
Loading…
Cancel
Save