@zkasm/zkevm-rom 0.0.1-security → 6.0.1

package/main/precompiled/selector.zkasm

@@ -0,0 +1,77 @@
+INCLUDE "pre-ecrecover.zkasm"
+INCLUDE "revert-precompiled.zkasm"
+INCLUDE "identity.zkasm"
+INCLUDE "pre-ecAdd.zkasm"
+INCLUDE "pre-ecMul.zkasm"
+INCLUDE "pre-ecPairing.zkasm"
+INCLUDE "pre-modexp.zkasm"
+INCLUDE "pre-sha2-256.zkasm"
+INCLUDE "../pairings/constants.zkasm"
+INCLUDE "../pairings/BN254/ecAdd.zkasm"
+INCLUDE "../pairings/BN254/ecMul.zkasm"
+INCLUDE "../pairings/ecPairing.zkasm"
+INCLUDE "../pairings/FRBN254/reduceFrBN254.zkasm"
+INCLUDE "../pairings/FPBN254/addFpBN254.zkasm"
+INCLUDE "../pairings/FPBN254/subFpBN254.zkasm"
+INCLUDE "../pairings/FPBN254/mulFpBN254.zkasm"
+INCLUDE "../pairings/FPBN254/squareFpBN254.zkasm"
+INCLUDE "../pairings/FPBN254/invFpBN254.zkasm"
+INCLUDE "../pairings/FPBN254/reduceFpBN254.zkasm"
+INCLUDE "../pairings/FP2BN254/addFp2BN254.zkasm"
+INCLUDE "../pairings/FP2BN254/subFp2BN254.zkasm"
+INCLUDE "../pairings/FP2BN254/mulFp2BN254.zkasm"
+INCLUDE "../pairings/FP2BN254/squareFp2BN254.zkasm"
+INCLUDE "../pairings/FP2BN254/escalarMulFp2BN254.zkasm"
+INCLUDE "../pairings/FP2BN254/invFp2BN254.zkasm"
+INCLUDE "../pairings/FP4BN254/squareFp4BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/addFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/subFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/mulFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/escalarMulFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/sparseMulAFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/sparseMulBFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/sparseMulCFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/squareFp6BN254.zkasm"
+INCLUDE "../pairings/FP6BN254/inverseFp6BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/mulFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/sparseMulAFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/sparseMulBFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/squareFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/inverseFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/frobFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/frob2Fp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/frob3Fp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/CYCLOFP12BN254/xBinDecompBN254.zkasm"
+INCLUDE "../pairings/FP12BN254/CYCLOFP12BN254/compressFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/CYCLOFP12BN254/decompressFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/CYCLOFP12BN254/squareCompCycloFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/CYCLOFP12BN254/squareCycloFp12BN254.zkasm"
+INCLUDE "../pairings/FP12BN254/CYCLOFP12BN254/expByXCompCycloFp12BN254.zkasm"
+INCLUDE "../pairings/BN254/addPointBN254.zkasm"
+INCLUDE "../pairings/BN254/escalarMulBN254.zkasm"
+INCLUDE "../pairings/BN254/lineSamePointsBN254.zkasm"
+INCLUDE "../pairings/BN254/lineDiffPointsBN254.zkasm"
+INCLUDE "../pairings/halfPairingBN254.zkasm"
+INCLUDE "../pairings/millerLoopBN254.zkasm"
+INCLUDE "../pairings/loopLengthBN254.zkasm"
+INCLUDE "../pairings/finalExpBN254.zkasm"
+INCLUDE "end.zkasm"
+
+/**
+ * Selector precompiled contract to run
+ * Current precompiled supported: ECRECOVER, SHA2-256, IDENTITY, MODEXP, ECADD, ECMUL, ECPAIRING
+ * @param {A} - Precompiled address
+ * @dev Any call to an unsupported precompiled will result in a revert
+ *  - All gas is refunded
+ *  - 0 is returned
+ */
+selectorPrecompiled:
+    A - 2               :JMPN(funcECRECOVER)
+    A - 3               :JMPN(funcSHA256)
+    A - 4               :JMPN(revertPrecompiled)  ;:JMPN(RIPEMD160)
+    A - 5               :JMPN(IDENTITY)
+    A - 6               :JMPN(revertPrecompiled)  ;:JMPN(funcModexp)
+    A - 7               :JMPN(funcEcAdd)
+    A - 8               :JMPN(funcEcMul)
+    A - 9               :JMPN(funcEcPairing)
+    A - 10              :JMPN(revertPrecompiled)  ;:JMPN(BLAKE2F)

package/main/process-change-l2-block.zkasm

@@ -0,0 +1,147 @@
+processChangeL2Block:
+
+    ; checks zk-counters
+    %MAX_CNT_POSEIDON_G - CNT_POSEIDON_G - %MAX_CNT_POSEIDON_SLOAD_SSTORE*6     :JMPN(outOfCountersPoseidon)
+    $ => A                                                                      :MLOAD(cntKeccakPreProcess)
+    %MAX_CNT_KECCAK_F - CNT_KECCAK_F - A - 2                                    :JMPN(outOfCountersKeccak)
+    %MAX_CNT_STEPS - STEP - 500                                                 :JMPN(outOfCountersStep)
+    %MAX_CNT_BINARY - CNT_BINARY - 8                                            :JMPN(outOfCountersBinary)
+
+    ; If it is not the first transaction, we must consolidate previous block
+    $ => A                              :MLOAD(currentTx)
+    A - 1                               :JMPZ(continueProcessChangeL2Block)
+                                        :CALL(consolidateBlock)
+
+continueProcessChangeL2Block:
+    $${eventLog(onStartBlock)}
+    ; Reset tx index, logIndex and cumulative gas used
+    0                                   :MSTORE(txIndex)
+    0                                   :MSTORE(cumulativeGasUsed)
+    0                                   :MSTORE(currentLogIndex)
+    ;; Set block hash (current state root) on storage
+    ; Update state root mapping
+    32 => D
+    0 => HASHPOS ; A new hash with position 0 is started
+    $ => E                              :MLOAD(lastHashKIdUsed)
+    E + 1 => E                          :MSTORE(lastHashKIdUsed)
+
+    %ADDRESS_SYSTEM => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => C                              :MLOAD(blockNum)
+    C                                   :HASHK(E)
+    %STATE_ROOT_STORAGE_POS             :HASHK(E)
+    HASHPOS                             :HASHKLEN(E)
+    $ => C                              :HASHKDIGEST(E)
+    SR => D                             :MSTORE(previousBlockHash)
+    $ => SR                             :SSTORE, CALL(initBlockInfoTree)
+
+    ; Read block number, increase it by 1 and write it
+    ; Get last block number
+    $ => A                              :MLOAD(blockNum)
+
+    ; Update last block number at system storage
+    1 => B
+    $ => D                              :ADD, MSTORE(blockNum)
+    %LAST_BLOCK_STORAGE_POS => C
+    %ADDRESS_SYSTEM => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => SR                             :SSTORE
+
+    ; Load current timestamp
+    %TIMESTAMP_STORAGE_POS => C
+    %ADDRESS_SYSTEM => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => A                              :SLOAD ; currentTimestamp => A
+
+    $ => B                              :MLOAD(timestampLimit) ; timestampLimit => B
+
+    ; If it is NOT a forced tx ==> verify Timestamp & L1InfoRoot
+    $                                   :MLOAD(isForced), JMPZ(verifyTimestampAndL1InfoRoot)
+
+    ; forced batch
+    ;   - update timestamp only if currentTimestamp < limitTimestamp
+    ;   - set blockHash to default
+    $ => C                              :MLOAD(forcedBlockHashL1)
+    C                                   :MSTORE(blockHashL1InfoTree)
+    A                                   :MSTORE(timestamp)
+    $                                   :LT, JMPNC(initSetGERL1InfoTree)
+
+newForcedTimestamp:
+    B                                   :MSTORE(timestamp), JMP(setNewTimestamp)
+
+verifyTimestampAndL1InfoRoot:
+    $ => B                              :MLOAD(deltaTimestamp)
+    ; Addition of two values of 8 bytes [B: currentTimestamp(A) + deltaTimestamp(B)]
+    $ => B                              :ADD, MSTORE(timestamp)
+
+    ; Verify (currentTimestamp + deltaTimestamp) <= limitTimestamp
+    $ => A                              :MLOAD(timestampLimit)
+    $                                   :LT, JMPC(invalidChangeL2BlockLimitTimestamp)
+
+    ; Set new timestamp
+    %TIMESTAMP_STORAGE_POS => C
+    %ADDRESS_SYSTEM => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => D                              :MLOAD(timestamp)
+    $ => SR                             :SSTORE
+
+    ; check indexL1InfoTree != 0 to verify data L1InfoTree
+    $                                                   :MLOAD(indexL1InfoTree), JMPZ(skipSetGERL1InfoTree)
+
+    ${getL1InfoGER(mem.indexL1InfoTree)} => A           :MSTORE(gerL1InfoTree)
+    ${getL1InfoBlockHash(mem.indexL1InfoTree)} => B     :MSTORE(blockHashL1InfoTree)
+    ${getL1InfoTimestamp(mem.indexL1InfoTree)} => C     :MSTORE(timestampL1InfoTree)
+                                                        :CALL(verifyMerkleProof)
+
+    ; Verify (currentTimestamp + deltaTimestamp) >= l1InfoRoot.timestamp
+    $ => A                                          :MLOAD(timestamp)
+    $ => B                                          :MLOAD(timestampL1InfoTree)
+    $                                               :LT, JMPC(invalidChangeL2BlockMinTimestamp, initSetGERL1InfoTree)
+
+setNewTimestamp:
+    ; Set new timestamp
+    %TIMESTAMP_STORAGE_POS => C
+    %ADDRESS_SYSTEM => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => D                                  :MLOAD(timestamp)
+    $ => SR                                 :SSTORE
+
+initSetGERL1InfoTree:
+    ; Set new GER
+    $ => A                                  :MLOAD(gerL1InfoTree)
+    ; If it is a forced tx ==> gerL1InfoTree = l1InfoRoot
+    $                                       :MLOAD(isForced), JMPZ(setGERL1InfoTree)
+    $ => A                                  :MLOAD(l1InfoRoot)
+    A                                       :MSTORE(gerL1InfoTree)
+
+setGERL1InfoTree:
+    0 => B
+    ; Do not set if zero
+    $                                       :EQ, JMPC(skipSetGERL1InfoTree)
+    0 => HASHPOS
+    $ => E                                  :MLOAD(lastHashKIdUsed)
+    E + 1 => E                              :MSTORE(lastHashKIdUsed)
+
+    32 => D
+    A                                       :HASHK(E)
+    %GLOBAL_EXIT_ROOT_STORAGE_POS           :HASHK(E) ; Storage position of the global exit root map
+    HASHPOS                                 :HASHKLEN(E)
+    $ => C                                  :HASHKDIGEST(E)
+
+    ; read blockHashL1InfoTree given the l1InfoRoot
+    ; skip overwrite blockHashL1 if it is different than 0 (already set)
+    %ADDRESS_GLOBAL_EXIT_ROOT_MANAGER_L2 => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => A                                  :SLOAD
+    0 => B
+    $                                       :EQ, JMPNC(skipSetGERL1InfoTree)
+
+    ; write blockhashL1
+    %ADDRESS_GLOBAL_EXIT_ROOT_MANAGER_L2 => A
+    %SMT_KEY_SC_STORAGE => B
+    $ => D                                  :MLOAD(blockHashL1InfoTree)
+    $ => SR                                 :SSTORE ; Store 'blockHashL1InfoTree' in storage position 'keccak256(gerL1InfoTree, 0)'
+
+skipSetGERL1InfoTree:
+                                            :CALL(setupNewBlockInfoTree)
+                                            :JMP(txLoop)