Feature/update eldelberry

.github/workflows/main.yaml

@@ -6,7 +6,7 @@ name: Test executor inputs
 on:
   workflow_dispatch:
   pull_request:
-    branches: [main, develop, develop-etrog, feature/fork-etrog, feature/l1-info-tree]
+    branches: [main, develop, develop-no-opt, develop-feijoa]
 
 jobs:
   build:
@@ -16,7 +16,7 @@ jobs:
         uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          node-version: 20
       - name: setup zkevm-rom
         run: |
           npm i
@@ -32,9 +32,9 @@ jobs:
           npm run test:zkasm
       - name: Generate tests
         run: |
-          npm run test:gen
+          node tools/parallel-testing/gen-parallel-tests.js
       - name: Run tests
         run: |
           export NUM_CPUS=31
           npm run test:start
-          sh tools/parallel-testing/checker.sh
+          sh tools/parallel-testing/checker.sh

counters/countersConstants.zkasm

@@ -24,7 +24,7 @@ CONST %SHRARITHBIT_CNT_PADDING_PG = 0 + %DIVARITH_CNT_PADDING_PG
 CONST %SHRARITHBIT_CNT_POSEIDON_G = 0 + %DIVARITH_CNT_POSEIDON_G
 ;offsetUtil
 CONST %OFFSETUTIL_STEP = 20
-CONST %OFFSETUTIL_CNT_BINARY = 1
+CONST %OFFSETUTIL_CNT_BINARY = 0
 CONST %OFFSETUTIL_CNT_ARITH = 0
 CONST %OFFSETUTIL_CNT_KECCAK_F = 0
 CONST %OFFSETUTIL_CNT_MEM_ALIGN = 0
@@ -55,7 +55,7 @@ CONST %MLOADX_CNT_MEM_ALIGN = 1 + %SHRARITH_CNT_MEM_ALIGN + %SHLARITH_CNT_MEM_AL
 CONST %MLOADX_CNT_PADDING_PG = 0 + %SHRARITH_CNT_PADDING_PG + %SHLARITH_CNT_PADDING_PG + %OFFSETUTIL_CNT_PADDING_PG
 CONST %MLOADX_CNT_POSEIDON_G = 0 + %SHRARITH_CNT_POSEIDON_G + %SHLARITH_CNT_POSEIDON_G + %OFFSETUTIL_CNT_POSEIDON_G
 ; MLOAD32
-CONST %MLOAD32_STEP = 100 + %OFFSETUTIL_STEP
+CONST %MLOAD32_STEP = 50 + %OFFSETUTIL_STEP
 CONST %MLOAD32_CNT_BINARY = 1 + %OFFSETUTIL_CNT_BINARY
 CONST %MLOAD32_CNT_ARITH = 0 + %OFFSETUTIL_CNT_ARITH
 CONST %MLOAD32_CNT_KECCAK_F = 0 + %OFFSETUTIL_CNT_KECCAK_F
@@ -201,15 +201,15 @@ CONST %OPBLOCKHASH_CNT_PADDING_PG = 0
 CONST %OPBLOCKHASH_CNT_POSEIDON_G = 2
 ; opCALLDATALOAD
 CONST %OPCALLDATALOAD_STEP = 100 + %SHLARITH_STEP + %SHRARITH_STEP + %DIVARITH_STEP
-CONST %OPCALLDATALOAD_CNT_BINARY = 3
+CONST %OPCALLDATALOAD_CNT_BINARY = 2
 CONST %OPCALLDATALOAD_CNT_ARITH = 0
 CONST %OPCALLDATALOAD_CNT_KECCAK_F = 0 + %SHLARITH_CNT_KECCAK_F + %SHRARITH_CNT_KECCAK_F + %DIVARITH_CNT_KECCAK_F
 CONST %OPCALLDATALOAD_CNT_MEM_ALIGN = 1
 CONST %OPCALLDATALOAD_CNT_PADDING_PG = 0 + %SHLARITH_CNT_PADDING_PG + %SHRARITH_CNT_PADDING_PG + %DIVARITH_CNT_PADDING_PG
 CONST %OPCALLDATALOAD_CNT_POSEIDON_G = 0 + %SHLARITH_CNT_POSEIDON_G + %SHRARITH_CNT_POSEIDON_G + %DIVARITH_CNT_POSEIDON_G
 ; opCALLDATACOPY - COMPLEX - hardcoded values at test
 CONST %OPCALLDATACOPY_STEP = 500
-CONST %OPCALLDATACOPY_CNT_BINARY = 21
+CONST %OPCALLDATACOPY_CNT_BINARY = 16
 CONST %OPCALLDATACOPY_CNT_ARITH = 8
 CONST %OPCALLDATACOPY_CNT_KECCAK_F = 0
 CONST %OPCALLDATACOPY_CNT_MEM_ALIGN = 2
@@ -225,87 +225,87 @@ CONST %OPRETURNDATACOPY_CNT_PADDING_PG = 0
 CONST %OPRETURNDATACOPY_CNT_POSEIDON_G = 0
 ; opCODECOPY - COMPLEX - hardcoded values at test
 CONST %OPCODECOPY_STEP = 1700
-CONST %OPCODECOPY_CNT_BINARY = 100
+CONST %OPCODECOPY_CNT_BINARY = 55
 CONST %OPCODECOPY_CNT_ARITH = 4
 CONST %OPCODECOPY_CNT_KECCAK_F = 0
 CONST %OPCODECOPY_CNT_MEM_ALIGN = 43
 CONST %OPCODECOPY_CNT_PADDING_PG = 0
 CONST %OPCODECOPY_CNT_POSEIDON_G = 0
 ; opEXTCODECOPY - COMPLEX - hardcoded values at test
 CONST %OPEXTCODECOPY_STEP = 2000
-CONST %OPEXTCODECOPY_CNT_BINARY = 104
+CONST %OPEXTCODECOPY_CNT_BINARY = 59
 CONST %OPEXTCODECOPY_CNT_ARITH = 4
 CONST %OPEXTCODECOPY_CNT_KECCAK_F = 0
 CONST %OPEXTCODECOPY_CNT_MEM_ALIGN = 43
 CONST %OPEXTCODECOPY_CNT_PADDING_PG = 0
 CONST %OPEXTCODECOPY_CNT_POSEIDON_G = 8
 ; opCREATE - COMPLEX - hardcoded values at test
 CONST %OPCREATE_STEP = 400
-CONST %OPCREATE_CNT_BINARY = 16
+CONST %OPCREATE_CNT_BINARY = 13
 CONST %OPCREATE_CNT_ARITH = 1
 CONST %OPCREATE_CNT_KECCAK_F = 0
 CONST %OPCREATE_CNT_MEM_ALIGN = 0
 CONST %OPCREATE_CNT_PADDING_PG = 0
 CONST %OPCREATE_CNT_POSEIDON_G = 23
 ; opCREATE2 - COMPLEX - hardcoded values at test
 CONST %OPCREATE2_STEP = 400
-CONST %OPCREATE2_CNT_BINARY = 21
+CONST %OPCREATE2_CNT_BINARY = 18
 CONST %OPCREATE2_CNT_ARITH = 2
 CONST %OPCREATE2_CNT_KECCAK_F = 0
 CONST %OPCREATE2_CNT_MEM_ALIGN = 0
 CONST %OPCREATE2_CNT_PADDING_PG = 0
 CONST %OPCREATE2_CNT_POSEIDON_G = 27
 ; opCALL - COMPLEX - hardcoded values at test
 CONST %OPCALL_STEP = 600
-CONST %OPCALL_CNT_BINARY = 27
+CONST %OPCALL_CNT_BINARY = 22
 CONST %OPCALL_CNT_ARITH = 3
 CONST %OPCALL_CNT_KECCAK_F = 0
 CONST %OPCALL_CNT_MEM_ALIGN = 0
 CONST %OPCALL_CNT_PADDING_PG = 0
 CONST %OPCALL_CNT_POSEIDON_G = 14
 ; opCALLCODE - COMPLEX - hardcoded values at test
 CONST %OPCALLCODE_STEP = 600
-CONST %OPCALLCODE_CNT_BINARY = 26
+CONST %OPCALLCODE_CNT_BINARY = 21
 CONST %OPCALLCODE_CNT_ARITH = 3
 CONST %OPCALLCODE_CNT_KECCAK_F = 0
 CONST %OPCALLCODE_CNT_MEM_ALIGN = 0
 CONST %OPCALLCODE_CNT_PADDING_PG = 0
 CONST %OPCALLCODE_CNT_POSEIDON_G = 10
 ; opRETURN - COMPLEX - hardcoded values at test
 CONST %OPRETURN_STEP = 700
-CONST %OPRETURN_CNT_BINARY = 35
+CONST %OPRETURN_CNT_BINARY = 25
 CONST %OPRETURN_CNT_ARITH = 11
 CONST %OPRETURN_CNT_KECCAK_F = 0
 CONST %OPRETURN_CNT_MEM_ALIGN = 4
 CONST %OPRETURN_CNT_PADDING_PG = 0
 CONST %OPRETURN_CNT_POSEIDON_G = 0
 ; opREVERT - COMPLEX - hardcoded values at test
 CONST %OPREVERT_STEP = 700
-CONST %OPREVERT_CNT_BINARY = 35
+CONST %OPREVERT_CNT_BINARY = 25
 CONST %OPREVERT_CNT_ARITH = 11
 CONST %OPREVERT_CNT_KECCAK_F = 0
 CONST %OPREVERT_CNT_MEM_ALIGN = 4
 CONST %OPREVERT_CNT_PADDING_PG = 0
 CONST %OPREVERT_CNT_POSEIDON_G = 0
 ; opDELEGATECALL - COMPLEX - hardcoded values at test
 CONST %OPDELEGATECALL_STEP = 600
-CONST %OPDELEGATECALL_CNT_BINARY = 23
+CONST %OPDELEGATECALL_CNT_BINARY = 18
 CONST %OPDELEGATECALL_CNT_ARITH = 3
 CONST %OPDELEGATECALL_CNT_KECCAK_F = 0
 CONST %OPDELEGATECALL_CNT_MEM_ALIGN = 0
 CONST %OPDELEGATECALL_CNT_PADDING_PG = 0
 CONST %OPDELEGATECALL_CNT_POSEIDON_G = 6
 ; opSTATICCALL - COMPLEX - hardcoded values at test
 CONST %OPSTATICCALL_STEP = 600
-CONST %OPSTATICCALL_CNT_BINARY = 23
+CONST %OPSTATICCALL_CNT_BINARY = 18
 CONST %OPSTATICCALL_CNT_ARITH = 3
 CONST %OPSTATICCALL_CNT_KECCAK_F = 0
 CONST %OPSTATICCALL_CNT_MEM_ALIGN = 0
 CONST %OPSTATICCALL_CNT_PADDING_PG = 0
 CONST %OPSTATICCALL_CNT_POSEIDON_G = 6
 ; opSHA3 - COMPLEX - hardcoded values at test
 CONST %OPSHA3_STEP = 3300
-CONST %OPSHA3_CNT_BINARY = 146
+CONST %OPSHA3_CNT_BINARY = 81
 CONST %OPSHA3_CNT_ARITH = 9
 CONST %OPSHA3_CNT_KECCAK_F = 15
 CONST %OPSHA3_CNT_MEM_ALIGN = 63
@@ -337,15 +337,15 @@ CONST %ISEMPTYACCOUNT_CNT_PADDING_PG = 0
 CONST %ISEMPTYACCOUNT_CNT_POSEIDON_G = 6
 ; computeGasSendCall
 CONST %COMPUTEGASSENDCALL_STEP = 30
-CONST %COMPUTEGASSENDCALL_CNT_BINARY = 2
+CONST %COMPUTEGASSENDCALL_CNT_BINARY = 1
 CONST %COMPUTEGASSENDCALL_CNT_ARITH = 0
 CONST %COMPUTEGASSENDCALL_CNT_KECCAK_F = 0
 CONST %COMPUTEGASSENDCALL_CNT_MEM_ALIGN = 0
 CONST %COMPUTEGASSENDCALL_CNT_PADDING_PG = 0
 CONST %COMPUTEGASSENDCALL_CNT_POSEIDON_G = 0
 ; saveMem
 CONST %SAVEMEM_STEP = 100 + %MULARITH_STEP + %DIVARITH_STEP
-CONST %SAVEMEM_CNT_BINARY = 5 + %MULARITH_CNT_BINARY + %DIVARITH_CNT_BINARY
+CONST %SAVEMEM_CNT_BINARY = 3 + %MULARITH_CNT_BINARY + %DIVARITH_CNT_BINARY
 CONST %SAVEMEM_CNT_ARITH = 0 + %MULARITH_CNT_ARITH + %DIVARITH_CNT_ARITH
 CONST %SAVEMEM_CNT_KECCAK_F = 0 + %MULARITH_CNT_KECCAK_F + %DIVARITH_CNT_KECCAK_F
 CONST %SAVEMEM_CNT_MEM_ALIGN = 0 + %MULARITH_CNT_MEM_ALIGN + %DIVARITH_CNT_MEM_ALIGN

counters/tests/MLOADX.zkasm

@@ -9,7 +9,7 @@ operation:
              :CALL(MLOADX)
 
     %MLOADX_STEP - STEP :JMPN(failedCounters)
-    5 - CNT_BINARY :JMPNZ(failedCounters)
+    4 - CNT_BINARY :JMPNZ(failedCounters)
     ;%MLOADX_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
     3 - CNT_ARITH :JMPNZ(failedCounters)
     ;%MLOADX_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)

counters/tests/MSTOREX.zkasm

@@ -15,7 +15,7 @@ operation:
              :CALL(MSTOREX)
 
     %MSTOREX_STEP - STEP:JMPN(failedCounters)
-    12 - CNT_BINARY :JMPNZ(failedCounters)
+    11 - CNT_BINARY :JMPNZ(failedCounters)
     ;%MSTOREX_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
     7 - CNT_ARITH :JMPNZ(failedCounters)
     ;%MSTOREX_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)

counters/tests/opCREATE2.zkasm

@@ -15,13 +15,6 @@ operation:
     1000     :MSTORE(SP++)
             :JMP(opCREATE2)
 checkCounters:
-%OPCREATE2_STEP - STEP:JMPN(failedCounters)
-%OPCREATE2_CNT_BINARY - CNT_BINARY :JMPNZ(failedCounters)
-%OPCREATE2_CNT_ARITH - CNT_ARITH :JMPNZ(failedCounters)
-%OPCREATE2_CNT_KECCAK_F - CNT_KECCAK_F :JMPNZ(failedCounters)
-%OPCREATE2_CNT_MEM_ALIGN - CNT_MEM_ALIGN :JMPNZ(failedCounters)
-%OPCREATE2_CNT_PADDING_PG - CNT_PADDING_PG :JMPNZ(failedCounters)
-%OPCREATE2_CNT_POSEIDON_G - CNT_POSEIDON_G :JMPNZ(failedCounters)
 
 0 => A,B,C,D,E,CTX, SP, PC, GAS,  SR, HASHPOS, RR ; Set all registers to 0
 finalizeExecution:

main/constants.zkasm

@@ -4,9 +4,9 @@ CONSTL %ADDRESS_SYSTEM = 0x000000000000000000000000000000005ca1ab1en
 CONST %MAX_STACK_SIZE = 1024
 CONST %BATCH_DIFFICULTY = 0
 CONST %TX_GAS_LIMIT = 30000000
-CONSTL %BLOCK_GAS_LIMIT = 2**64-1
+CONSTL %BLOCK_GAS_LIMIT = 2**50
 CONST %MAX_MEM_EXPANSION_BYTES = 0x3fffe0
-CONST %FORK_ID = 7
+CONST %FORK_ID = 8
 CONST %L1INFO_TREE_LEVELS = 32
 CONST %CALLDATA_RESERVED_CTX = 1
 CONSTL %FOUR_GOLDILOCKS = 0xffffffff00000001ffffffff00000001ffffffff00000001ffffffff00000001n

main/ecrecover/FNSECP256K1/invFnSecp256k1.zkasm

@@ -0,0 +1,42 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PRE: A is not alias-free
+;; POST: The result B is not alias-free (on MAP)
+;;
+;; invFnSecp256k1:
+;;             in: A
+;;             out: B = A⁻¹ (mod n)
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; RESOURCES:
+;   non-normalized: 2 ariths + 2 binaries + 13 steps
+;   normalized: 2 ariths + 1 binaries + 12 steps
+;   TOTAL (worst case): 2 ariths + 2 binaries + 13 steps
+
+VAR GLOBAL invFnSecp256k1_tmp
+
+invFnSecp256k1:
+
+        ; Reduction of A
+        %SECP256K1_N => B
+        $       :LT, JMPC(invFnSecp256k1_normalized)
+        $ => A  :SUB
+
+invFnSecp256k1_normalized:
+
+        ; 1] Compute and check the inverse over Z
+        ; A·A⁻¹ + 0 = [D]·2²⁵⁶ + [E]
+        0 => C
+        ${var _invFnSecp256k1_A = inverseFnEc(A)} => B :MSTORE(invFnSecp256k1_tmp)
+        $${var _invFnSecp256k1_AB = A * _invFnSecp256k1_A}
+        ${_invFnSecp256k1_AB >> 256} => D
+        ${_invFnSecp256k1_AB} => E :ARITH
+
+        ; 2] Check it over Fn, that is, it must be satisfied that:
+        ; n·[(A·A⁻¹) / n] + 1 = D·2²⁵⁶ + E
+        %SECP256K1_N => A
+        ${_invFnSecp256k1_AB / const.SECP256K1_N} => B
+        1 => C
+        E :ARITH
+
+        $ => B   :MLOAD(invFnSecp256k1_tmp), RETURN

main/ecrecover/FNSECP256K1/mulFnSecp256k1.zkasm

@@ -0,0 +1,28 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PRE: A,B are not alias-free
+;; POST: The result C is not alias-free (on MAP)
+;;
+;; mulFnSecp256k1:
+;;             in: A,B
+;;             out: C = A·B (mod n)
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; RESOURCES:
+;   2 arith + 8 steps
+
+mulFnSecp256k1:
+
+        ; 1] Compute and check the multiplication over Z
+        ; A·B + 0 = [D]·2²⁵⁶ + [E]
+        0 => C
+        $${var _mulFnSecp256k1_AB = A * B}
+        ${_mulFnSecp256k1_AB >> 256} => D
+        ${_mulFnSecp256k1_AB} => E :ARITH
+
+        ; 2] Check it over Fn, that is, it must be satisfied that:
+        ; n·[(A·B) / n] + [(A·B) % n] = D·2²⁵⁶ + E
+        %SECP256K1_N => A
+        ${_mulFnSecp256k1_AB / const.SECP256K1_N} => B        ; quotient (256 bits)
+        ${_mulFnSecp256k1_AB % const.SECP256K1_N} => C        ; residue  (256 bits)
+        E :ARITH, RETURN

main/ecrecover/FPSECP256K1/addFpSecp256k1.zkasm

@@ -0,0 +1,29 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PRE: A,C are not alias-free
+;; POST: The result C is not alias-free (on MAP)
+;;
+;; addFpSecp256k1:
+;;             in: A,C
+;;             out: C = A + C (mod p)
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; RESOURCES:
+;   2 ariths + 8 steps
+
+addFpSecp256k1:
+
+        ; 1] Compute and check the sum over Z
+        ; A·[1] + C = [D]·2²⁵⁶ + [E]
+        1 => B
+        $${var _addFpSecp256k1_AC = A + C}
+        ${_addFpSecp256k1_AC >> 256} => D
+        ${_addFpSecp256k1_AC} => E :ARITH
+
+        ; 2] Check it over Fp, that is, it must be satisfied that:
+        ; p·[(A+C) / p] + [(A+C) % p] = D·2²⁵⁶ + E
+        %SECP256K1_P => A
+        ${_addFpSecp256k1_AC / const.SECP256K1_P} => B        ; quotient  (256 bits)
+        ${_addFpSecp256k1_AC % const.SECP256K1_P} => C        ; residue (256 bits)
+
+        E :ARITH, RETURN