zkevm-rom 0.0.1-security → 6.0.1

package/tools/modexp-utils/modexp-test-gen.js

@@ -0,0 +1,168 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const filePath = path.join(__dirname, 'tmpTest.zkasm');
+
+const fileBefore =
+`; constants needed by executor C++
+CONST %N = 2**19
+CONST %MAX_CNT_STEPS_LIMIT = %N
+CONST %MAX_CNT_ARITH_LIMIT = %N
+CONST %MAX_CNT_BINARY_LIMIT = %N
+CONST %MAX_CNT_MEM_ALIGN_LIMIT = %N
+CONST %MAX_CNT_KECCAK_F_LIMIT = %N
+CONST %MAX_CNT_PADDING_PG_LIMIT = %N
+CONST %MAX_CNT_POSEIDON_G_LIMIT = %N
+
+VAR GLOBAL lastHashKId
+VAR GLOBAL lastHashPId
+
+VAR GLOBAL initial_A
+VAR GLOBAL initial_B
+VAR GLOBAL initial_C
+VAR GLOBAL initial_D
+VAR GLOBAL initial_E
+VAR GLOBAL initial_CTX
+VAR GLOBAL initial_SP
+VAR GLOBAL initial_PC
+VAR GLOBAL initial_GAS
+VAR GLOBAL initial_SR
+VAR GLOBAL initial_RR
+VAR GLOBAL initial_HASHPOS
+VAR GLOBAL initial_RCX
+
+start:
+
+        STEP => A
+        0 :ASSERT
+
+        A           :MSTORE(initial_A)
+        B           :MSTORE(initial_B)
+        C           :MSTORE(initial_C)
+        D           :MSTORE(initial_D)
+        E           :MSTORE(initial_E)
+        CTX         :MSTORE(initial_CTX)
+        SP          :MSTORE(initial_SP)
+        PC          :MSTORE(initial_PC)
+        GAS         :MSTORE(initial_GAS)
+        SR          :MSTORE(initial_SR)
+        RR          :MSTORE(initial_RR)
+        HASHPOS     :MSTORE(initial_HASHPOS)
+        RCX         :MSTORE(initial_RCX)
+        0 => A,B,C,D,E,CTX, SP, PC, GAS, SR, RR, HASHPOS, RCX
+
+        -1          :MSTORE(lastHashKId)
+        -1          :MSTORE(lastHashPId)
+`;
+const fileAfter = 
+`
+end:
+
+        $ => A           :MLOAD(initial_A)
+        $ => B           :MLOAD(initial_B)
+        $ => C           :MLOAD(initial_C)
+        $ => D           :MLOAD(initial_D)
+        $ => E           :MLOAD(initial_E)
+        $ => CTX         :MLOAD(initial_CTX)
+        $ => SP          :MLOAD(initial_SP)
+        $ => PC          :MLOAD(initial_PC)
+        $ => GAS         :MLOAD(initial_GAS)
+        $ => SR          :MLOAD(initial_SR)
+        $ => RR          :MLOAD(initial_RR)
+        $ => HASHPOS     :MLOAD(initial_HASHPOS)
+        $ => RCX         :MLOAD(initial_RCX)
+
+; label finalizeExecution needed by executor C++
+finalizeExecution:
+        \${beforeLast()}  : JMPN(finalizeExecution)
+
+                         : JMP(start)
+opINVALID:
+; label checkAndSaveFrom needed by executor C++
+checkAndSaveFrom:
+                         :JMP(opINVALID)
+
+INCLUDE "../main/modexp/array_lib/utils/array_trim.zkasm"
+INCLUDE "../main/modexp/array_lib/utils/array_compare.zkasm"
+
+INCLUDE "../main/modexp/array_lib/array_add_AGTB.zkasm"
+INCLUDE "../main/modexp/array_lib/array_add_short.zkasm"
+INCLUDE "../main/modexp/array_lib/array_mul.zkasm"
+INCLUDE "../main/modexp/array_lib/array_mul_long.zkasm"
+INCLUDE "../main/modexp/array_lib/array_mul_short.zkasm"
+INCLUDE "../main/modexp/array_lib/array_div.zkasm"
+INCLUDE "../main/modexp/array_lib/array_div_long.zkasm"
+INCLUDE "../main/modexp/array_lib/array_div_short.zkasm"
+`;
+
+const counters = [];
+
+for (let i = 1; i <= 5; i++) {
+    for (let j = 1; j <= i; j++) {
+        for (let k = 1; k <= j; k++) {
+            console.log(`Test (${i},${j},${k}):`);
+
+            // Define the test
+            let fileTest1 = `\t${i} => C\n\t${j} => D\n\t115792089237316195423570985008687907853269984665640564039457584007913129639933n              :MSTORE(array_mul_inA)\n\t115792089237316195423570985008687907853269984665640564039457584007913129639933n              :MSTORE(array_mul_inB)\n`
+
+            for (let l = 1; l < j; l++) {
+                fileTest1 += `\t${l} => E\n\t115792089237316195423570985008687907853269984665640564039457584007913129639933n              :MSTORE(array_mul_inA + E)\n`
+                fileTest1 += `\t115792089237316195423570985008687907853269984665640564039457584007913129639933n              :MSTORE(array_mul_inB + E)\n`
+            }
+
+            for (let l = j; l < i; l++) {
+                fileTest1 += `\t${l} => E\n\t115792089237316195423570985008687907853269984665640564039457584007913129639933n              :MSTORE(array_mul_inA + E)\n`
+            }
+
+            const fileTest2 = `\t\t:CALL(array_mul)\n\t${i+j} => C\n\t${k} => D\n\t`
+
+            let fileTest3 =`$ => A          :MLOAD(array_mul_out)\n\tA               :MSTORE(array_div_inA)\n\t115792089237316195423570985008687907853269984665640564039457584007913129639935n                 :MSTORE(array_div_inB)\n\t`
+
+            for (let l = 1; l < k; l++) {
+                fileTest3 += `${l} => E\n\t$ => A          :MLOAD(array_mul_out + E)\n\tA               :MSTORE(array_div_inA + E)\n\t115792089237316195423570985008687907853269984665640564039457584007913129639935n                 :MSTORE(array_div_inB + E)\n\t`
+            }
+
+            for (let l = k; l < i + j; l++) {
+                fileTest3 += `${l} => E\n\t$ => A          :MLOAD(array_mul_out + E)\n\tA               :MSTORE(array_div_inA + E)\n\t`
+            }
+
+            fileTest3 += `:CALL(array_div)\n`;
+
+            const fileTest = fileTest1 + fileTest2 + fileTest3;
+
+            // Create the file
+            fs.writeFileSync(filePath, fileBefore + fileTest + fileAfter);
+
+            const output = execSync(
+                `node node_modules/@0xpolygonhermez/zkevm-proverjs/test/zkasmtest.js ${filePath} -H ./main/modexp/helper.js -N "2**24" -d`
+            ).toString();
+
+            // Capture the counters
+            const pattern = /cntArith: (\d+)n,\n  cntBinary: (\d+)n,\n  cntKeccakF: (\d+)n,\n  cntMemAlign: (\d+)n,\n  cntPoseidonG: (\d+)n,\n  cntPaddingPG: (\d+)n,\n  cntSteps: (\d+)/;
+            const matches = output.match(pattern);
+
+            if (matches) {
+                const [,cntArith, cntBinary, , , , , cntSteps] = matches.map(Number);
+                const testCounters = {
+                    lenR: i,
+                    lenB: j,
+                    lenM: k,
+                    cntArith,
+                    cntBinary,
+                    cntSteps,
+                };
+                console.log(testCounters);
+                counters.push(testCounters);
+            } else {
+                console.log('Something wrong happened with the output');
+            }
+
+            // Delete the file
+            fs.unlinkSync(filePath);
+        }
+    }
+}
+
+// Write the counters to a JSON file
+fs.writeFileSync(path.join(__dirname, 'modexp-counters.json'), JSON.stringify(counters));

package/tools/modexp-utils/modexp-test-int.sage

@@ -0,0 +1,37 @@
+import json
+import os
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+with open(dir_path + '/modexp-counters.json') as f:
+    data = json.load(f)
+
+points = []
+valuesArith = []
+valuesBinary = []
+valuesSteps = []
+for i in range(0, len(data)):
+    points.append([data[i]['lenR'],data[i]['lenB'],data[i]['lenM']])
+    valuesArith.append(data[i]['cntArith'])
+    valuesBinary.append(data[i]['cntBinary'])
+    valuesSteps.append(data[i]['cntSteps'])
+
+R.<x,y,z> = PolynomialRing(QQ)
+
+def findInterpolation(points, values):
+    for i in range(1, 11):
+        for j in range(1, i+1):
+            for k in range(1, j+1):
+                try:
+                    f = R.interpolation([i,j,k], points, values)
+                    return f
+                except:
+                    pass
+
+f1 = findInterpolation(points, valuesArith)
+f2 = findInterpolation(points, valuesBinary)
+f3 = findInterpolation(points, valuesSteps)
+print("f1",f1)
+print("f2",f2)
+print("f3",f3)
+print(f1(3,2,1), f2(3,2,1), f3(3,2,1))

package/tools/parallel-testing/checker.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+FILE=$PWD/tools/parallel-testing/parallel-tests/checker.txt
+if [ -f "$FILE" ]; then
+    cat "$FILE"
+    exit 1
+fi

package/tools/parallel-testing/gen-parallel-tests.js

@@ -0,0 +1,78 @@
+/* eslint-disable no-console */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable no-restricted-syntax */
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+const { compile } = require('pilcom');
+const buildPoseidon = require('@0xpolygonhermez/zkevm-commonjs').getPoseidon;
+
+const folderPaths = [
+    '../../node_modules/@0xpolygonhermez/zkevm-testvectors/inputs-executor',
+    '../../node_modules/@0xpolygonhermez/zkevm-testvectors/inputs-executor/ethereum-tests/GeneralStateTests',
+];
+
+const fileCachePil = path.join(__dirname, '../../node_modules/@0xpolygonhermez/zkevm-proverjs/cache-main-pil.json');
+const pathMainPil = path.join(__dirname, '../../node_modules/@0xpolygonhermez/zkevm-proverjs/pil/main.pil');
+const inputs = [];
+const testsFolder = path.join(__dirname, 'parallel-tests');
+const sampleDir = path.join(__dirname, 'parallel-tests-sample/sample.test.js');
+const { argv } = require('yargs');
+
+async function genTestsFiles() {
+    if (!fs.existsSync(testsFolder)) {
+        fs.mkdirSync(testsFolder);
+    }
+    for (const inputPath of inputs) {
+        const name = inputPath.split('/').slice(-1)[0].replace('json', 'test.js');
+        const sample = fs.readFileSync(sampleDir, 'utf-8');
+        let test = sample.replace('%%INPUT_PATH%%', `${inputPath}`);
+        // Replace skip vcounters flag
+        if (argv.skipVCounters) {
+            test = test.replace('%%SKIP_VCOUNTERS%%', 'yes');
+        }
+        fs.writeFileSync(`${testsFolder}/${name}`, test);
+    }
+    expect(true).to.be.equal(true);
+}
+
+async function main() {
+    const poseidon = await buildPoseidon();
+    const { F } = poseidon;
+
+    // Add all test files to `inputs` array
+    for (const folder of folderPaths) {
+        const inputsPath = path.join(__dirname, folder);
+        fs.readdirSync(inputsPath).forEach((file) => {
+            const filePath = path.join(inputsPath, file);
+            // Remove json lists that are generated with gen inputs script and are not inputs
+            if (file.endsWith('.json') && !file.includes('testsOOC-list.json') && !file.includes('tests30M-list.json') && !file.includes('no-exec')) {
+                inputs.push(filePath);
+            } else if (fs.statSync(filePath).isDirectory() && !filePath.includes('tests-OOC')) {
+                fs.readdirSync(filePath).forEach((subFile) => {
+                    const subFilePath = path.join(filePath, subFile);
+                    if (subFile.endsWith('.json') && !subFile.includes('testsOOC-list.json') && !subFile.includes('tests30M-list.json') && !subFile.includes('no-exec')) {
+                        inputs.push(subFilePath);
+                    }
+                });
+            }
+        });
+    }
+
+    console.log(`Inputs executor generated: ${inputs.length}`);
+
+    const pilConfig = {
+        defines: { N: 4096 },
+        namespaces: ['Main', 'Global'],
+        disableUnusedError: true,
+    };
+
+    const pil = await compile(F, pathMainPil, null, pilConfig);
+    fs.writeFileSync(fileCachePil, `${JSON.stringify(pil, null, 1)}\n`, 'utf8');
+    genTestsFiles();
+    // Generate counters diff table csv file
+    fs.writeFileSync(path.join(__dirname, 'countersDiffs.csv'), 'Test name,vSteps,rSteps,StepsDiff,vArith,rArith,ArithDiff,vBinary,rBinary,BinaryDiff,vMemAlign,rMemAlign,memAlignDiff,vKeccaks,rKeccaks,keccaksDiff,vPoseidon,rPoseidon,PoseidonDiff,vPadding,rPadding,PaddingDiff,vSHA256,rSHA256,SHA256Diff\n', 'utf8');
+}
+
+main();

package/tools/parallel-testing/parallel-tests-sample/sample.test.js

@@ -0,0 +1,136 @@
+/* eslint-disable global-require */
+/* eslint-disable import/no-dynamic-require */
+/* eslint-disable no-use-before-define */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable import/extensions */
+/* eslint-disable import/no-unresolved */
+const { expect } = require('chai');
+const fs = require('fs');
+const path = require('path');
+
+const { newCommitPolsArray } = require('pilcom');
+const smMain = require('@0xpolygonhermez/zkevm-proverjs/src/sm/sm_main/sm_main');
+
+let rom = require('../../../build/rom.json');
+
+let stepsN = 2 ** 23;
+let counters = false;
+
+const fileCachePil = path.join(__dirname, '../../../node_modules/@0xpolygonhermez/zkevm-proverjs/cache-main-pil.json');
+
+const checkerDir = path.join(__dirname, 'checker.txt');
+
+const inputPath = '%%INPUT_PATH%%';
+const nameFile = path.basename(inputPath);
+const input = JSON.parse(fs.readFileSync(inputPath, 'utf8'));
+const skipVcounters = '%%SKIP_VCOUNTERS%%';
+
+it(`${nameFile}`, async () => {
+    if (fs.existsSync(checkerDir)) {
+        process.exit(1);
+    }
+    const pil = JSON.parse(fs.readFileSync(fileCachePil));
+    const cmPols = newCommitPolsArray(pil);
+    if (input.gasLimit) {
+        rom = require(`../../../build/rom-${input.gasLimit}.test.json`);
+    }
+    if (input.stepsN) {
+        stepsN = input.stepsN;
+        counters = true;
+    }
+    await runTest(cmPols, stepsN);
+
+    expect(true).to.be.equal(true);
+});
+
+async function runTest(cmPols, steps) {
+    try {
+        const config = {
+            debug: true,
+            debugInfo: {
+                inputName: path.basename(inputPath),
+            },
+            stepsN: steps,
+            counters,
+            assertOutputs: true,
+        };
+
+        const res = await smMain.execute(cmPols.Main, input, rom, config);
+        if (skipVcounters !== 'yes') {
+            compareCounters(input.virtualCounters, res.counters);
+        }
+    } catch (err) {
+        fs.writeFileSync(checkerDir, `Failed test ${inputPath} - ${err}}`);
+        throw err;
+    }
+}
+
+function compareCounters(virtualCounters, result) {
+    const countersDiff = {
+        steps: {
+            virtual: virtualCounters.steps,
+            real: Number(result.cntSteps),
+            diff: getPercentageDiff(virtualCounters.steps, Number(result.cntSteps)),
+        },
+        arith: {
+            virtual: virtualCounters.arith,
+            real: Number(result.cntArith),
+            diff: getPercentageDiff(virtualCounters.arith, Number(result.cntArith)),
+        },
+        binary: {
+            virtual: virtualCounters.binary,
+            real: Number(result.cntBinary),
+            diff: getPercentageDiff(virtualCounters.binary, Number(result.cntBinary)),
+        },
+        memAlign: {
+            virtual: virtualCounters.memAlign,
+            real: Number(result.cntMemAlign),
+            diff: getPercentageDiff(virtualCounters.memAlign, Number(result.cntMemAlign)),
+        },
+        keccaks: {
+            virtual: virtualCounters.keccaks,
+            real: Number(result.cntKeccakF),
+            diff: getPercentageDiff(virtualCounters.keccaks, Number(result.cntKeccakF)),
+        },
+        poseidon: {
+            virtual: virtualCounters.poseidon,
+            real: Number(result.cntPoseidonG),
+            diff: getPercentageDiff(virtualCounters.poseidon, Number(result.cntPoseidonG)),
+        },
+        padding: {
+            virtual: virtualCounters.padding,
+            real: Number(result.cntPaddingPG),
+            diff: getPercentageDiff(virtualCounters.padding, Number(result.cntPaddingPG)),
+        },
+        sha256: {
+            virtual: virtualCounters.sha256,
+            real: Number(result.cntSha256F),
+            diff: getPercentageDiff(virtualCounters.sha256, Number(result.cntSha256F)),
+        },
+    };
+    fs.appendFileSync(path.join(__dirname, '../countersDiffs.csv'), `${nameFile},${countersDiff.steps.virtual},${countersDiff.steps.real},${String(countersDiff.steps.diff).replace('.', ',')},${countersDiff.arith.virtual},${countersDiff.arith.real},${String(countersDiff.arith.diff).replace('.', ',')},${countersDiff.binary.virtual},${countersDiff.binary.real},${String(countersDiff.binary.diff).replace('.', ',')},${countersDiff.memAlign.virtual},${countersDiff.memAlign.real},${String(countersDiff.memAlign.diff).replace('.', ',')},${countersDiff.keccaks.virtual},${countersDiff.keccaks.real},${String(countersDiff.keccaks.diff).replace('.', ',')},${countersDiff.poseidon.virtual},${countersDiff.poseidon.real},${String(countersDiff.poseidon.diff).replace('.', ',')},${countersDiff.padding.virtual},${countersDiff.padding.real},${String(countersDiff.padding.diff).replace('.', ',')},${countersDiff.sha256.virtual},${countersDiff.sha256.real},${String(countersDiff.sha256.diff).replace('.', ',')}\n`);
+    // Check percentages are greater than 0
+    Object.keys(countersDiff).forEach((key) => {
+        if (Number(countersDiff[key].diff) < 0) {
+            throw new Error(`Negative percentage diff: ${countersDiff[key].virtual}/${countersDiff[key].real}/${countersDiff[key].diff}% at ${key}}`);
+        }
+    });
+}
+
+function getPercentageDiff(a, b) {
+    if (a === 0) {
+        // a and b are 0
+        if (b === 0) {
+            return 0;
+        }
+        // a is 0 but b is not -> fail test
+
+        return -100;
+    }
+    // a is not 0 but b is -> passed
+    if (b === 0) {
+        return 0;
+    }
+
+    return (((a - b) / b) * 100).toFixed(2);
+}

package/tools/run-tests-zkasm.js

@@ -0,0 +1,83 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable no-use-before-define */
+const path = require('path');
+const chalk = require('chalk');
+const zkasm = require('@0xpolygonhermez/zkasmcom');
+const smMain = require('@0xpolygonhermez/zkevm-proverjs/src/sm/sm_main/sm_main');
+
+const emptyInput = require('@0xpolygonhermez/zkevm-proverjs/test/inputs/empty_input.json');
+
+const { argv } = require('yargs')
+    .alias('v', 'verbose');
+
+const { compilePil, getTestFiles } = require('./helpers/helpers');
+
+async function main() {
+    // Compile pil
+    console.log(chalk.yellow('--> Compile PIL'));
+    const cmPols = await compilePil();
+
+    // Get all zkasm files
+    const pathZkasm = path.join(process.cwd(), process.argv[2]);
+    const files = await getTestFiles(pathZkasm);
+
+    let wasFailed = false;
+    // Run all zkasm files
+    // eslint-disable-next-line no-restricted-syntax
+    console.log(chalk.yellow('--> Start running zkasm files'));
+    for (const file of files) {
+
+        if (file.includes('ignore')) {
+          continue; 
+        }
+
+        if (await runTest(file, cmPols) == 1) {
+            wasFailed = true;
+        }
+    }
+    if (wasFailed) {
+        process.exit(1);
+    }
+}
+
+// returns true if test succeed and false if test failed
+async function runTest(pathTest, cmPols) {
+    // Compile rom
+    const configZkasm = {
+        defines: [],
+        allowUndefinedLabels: true,
+        allowOverwriteLabels: true,
+    };
+
+    const config = {
+        debug: true,
+        stepsN: 8388608,
+        assertOutputs: false,
+    };
+    let failed = false;
+    // execute zkasm tests
+    try {
+        console.log(chalk.blue('   --> start'), pathTest);
+        const rom = await zkasm.compile(pathTest, null, configZkasm);
+        const result = await smMain.execute(cmPols.Main, emptyInput, rom, config);
+        console.log(chalk.green('   --> pass'), pathTest);
+        if (argv.verbose) {
+            console.log(chalk.blue('   --> verbose'));
+            console.log(chalk.blue('        --> counters'));
+            console.log(result.counters);
+            console.log(chalk.blue('        --> outputs'));
+            console.log(result.output);
+            console.log(chalk.blue('        --> logs'));
+            console.log(result.logs);
+        }
+    } catch (e) {
+        console.log(chalk.red('   --> fail'), pathTest);
+        console.log(e);
+        failed = true;
+    }
+
+    return failed;
+}
+
+main();