EIP-7823 and EIP-7883 implementation --- Osaka MODEXP changes

arithmetization/src/main/java/net/consensys/linea/zktracer/ZkCounter.java

@@ -16,16 +16,14 @@
 package net.consensys.linea.zktracer;
 
 import static net.consensys.linea.zktracer.Fork.*;
-import static net.consensys.linea.zktracer.Trace.*;
 import static net.consensys.linea.zktracer.Trace.BLOCKHASH_MAX_HISTORY;
 import static net.consensys.linea.zktracer.Trace.Ecdata.TOTAL_SIZE_ECPAIRING_DATA_MIN;
 import static net.consensys.linea.zktracer.TraceCancun.Oob.CT_MAX_CALL;
 import static net.consensys.linea.zktracer.TraceCancun.Oob.CT_MAX_CREATE;
 import static net.consensys.linea.zktracer.module.ModuleName.*;
 import static net.consensys.linea.zktracer.module.ModuleName.GAS;
 import static net.consensys.linea.zktracer.module.add.AddOperation.NB_ROWS_ADD;
-import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpDataOperation.NB_ROWS_BLAKEMODEPX_BLAKE;
-import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpDataOperation.NB_ROWS_BLAKEMODEXP_MODEXP;
+import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpOperation.*;
 import static net.consensys.linea.zktracer.module.blockdata.module.CancunBlockData.NB_ROWS_BLOCK_DATA;
 import static net.consensys.linea.zktracer.module.blockhash.BlockhashOperation.NB_ROWS_BLOCKHASH;
 import static net.consensys.linea.zktracer.module.gas.GasOperation.NB_ROWS_GAS;
@@ -48,7 +46,7 @@
 import static net.consensys.linea.zktracer.module.hub.section.call.precompileSubsection.BlakeSubsection.NB_ROWS_HUB_PRC_BLAKE;
 import static net.consensys.linea.zktracer.module.hub.section.call.precompileSubsection.EllipticCurvePrecompileSubsection.NB_ROWS_HUB_PRC_ELLIPTIC_CURVE;
 import static net.consensys.linea.zktracer.module.hub.section.call.precompileSubsection.IdentitySubsection.NB_ROWS_HUB_PRC_IDENTITY;
-import static net.consensys.linea.zktracer.module.hub.section.call.precompileSubsection.ModexpSubsection.NB_ROWS_HUB_PRC_MODEXP;
+import static net.consensys.linea.zktracer.module.hub.section.call.precompileSubsection.LondonModexpSubsection.NB_ROWS_HUB_PRC_MODEXP;
 import static net.consensys.linea.zktracer.module.hub.section.call.precompileSubsection.ShaTwoOrRipemdSubSection.NB_ROWS_HUB_PRC_SHARIP;
 import static net.consensys.linea.zktracer.module.hub.section.copy.CallDataCopySection.NB_ROWS_HUB_CALL_DATA_COPY;
 import static net.consensys.linea.zktracer.module.hub.section.copy.CodeCopySection.NB_ROWS_HUB_CODE_COPY;
@@ -108,7 +106,9 @@
 import net.consensys.linea.zktracer.module.hub.fragment.imc.exp.ExplogExpCall;
 import net.consensys.linea.zktracer.module.hub.fragment.imc.exp.ModexpLogExpCall;
 import net.consensys.linea.zktracer.module.hub.fragment.scenario.PrecompileScenarioFragment;
-import net.consensys.linea.zktracer.module.hub.precompiles.ModexpMetadata;
+import net.consensys.linea.zktracer.module.hub.precompiles.modexpMetadata.LondonModexpMetadata;
+import net.consensys.linea.zktracer.module.hub.precompiles.modexpMetadata.ModexpMetadata;
+import net.consensys.linea.zktracer.module.hub.precompiles.modexpMetadata.OsakaModexpMetadata;
 import net.consensys.linea.zktracer.module.limits.BlockTransactions;
 import net.consensys.linea.zktracer.module.limits.Keccak;
 import net.consensys.linea.zktracer.module.limits.L1BlockSize;
@@ -137,7 +137,7 @@
 @Slf4j
 public class ZkCounter implements LineCountingTracer {
 
-  public static final Fork FORK_TO_USE_FOR_ZK_COUNTER = OSAKA;
+  public static final Fork FORK_TO_USE_FOR_ZK_COUNTER = PRAGUE;
 
   private final OpCodes opCodes = OpCodes.load(FORK_TO_USE_FOR_ZK_COUNTER);
   private static final Trace trace = getTraceFromFork(FORK_TO_USE_FOR_ZK_COUNTER);
@@ -726,12 +726,15 @@ public void tracePrecompileCall(MessageFrame frame, long gasRequirement, Bytes o
       case PRC_MODEXP -> {
         hub.updateTally(NB_ROWS_HUB_PRC_MODEXP);
         final MemoryRange memoryRange = new MemoryRange(0, 0, callData.size(), callData);
-        final ModexpMetadata modexpMetadata = new ModexpMetadata(memoryRange);
+        final ModexpMetadata modexpMetadata =
+                forkPredatesOsaka(FORK_TO_USE_FOR_ZK_COUNTER)
+                        ? new LondonModexpMetadata(memoryRange)
+                        : new OsakaModexpMetadata(memoryRange);
         if (modexpMetadata.unprovableModexp()) {
           modexpEffectiveCall.detectEvent();
           return;
         }
-        blakemodexp.updateTally(NB_ROWS_BLAKEMODEXP_MODEXP);
+        blakemodexp.updateTally(modexpMetadata.getNumberOfRowsForModexp());
         modexpEffectiveCall.updateTally(prcSuccess);
         modexpLargeCall.updateTally(modexpMetadata.largeModexp());
         if (modexpMetadata.loadRawLeadingWord()) {
@@ -755,7 +758,7 @@ public void tracePrecompileCall(MessageFrame frame, long gasRequirement, Bytes o
         blakeEffectiveCall.updateTally(true);
         hub.updateTally(NB_ROWS_HUB_PRC_BLAKE);
         oob.updateTally(oobLineCountForPrc(PRC_BLAKE2F));
-        blakemodexp.updateTally(NB_ROWS_BLAKEMODEPX_BLAKE);
+        blakemodexp.updateTally(numberOfRowsBlake());
         // TODO: still unchecked module for now: blakeRounds.updateTally();
       }
       case PRC_BLS_G1_ADD,

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blake2fmodexpdata/BlakeComponents.java

@@ -15,8 +15,8 @@
 
 package net.consensys.linea.zktracer.module.blake2fmodexpdata;
 
-import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpDataOperation.BLAKE2f_HASH_INPUT_OFFSET;
-import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpDataOperation.BLAKE2f_HASH_INPUT_SIZE;
+import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpOperation.BLAKE2f_HASH_INPUT_OFFSET;
+import static net.consensys.linea.zktracer.module.blake2fmodexpdata.BlakeModexpOperation.BLAKE2f_HASH_INPUT_SIZE;
 
 import org.apache.tuweni.bytes.Bytes;
 

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blake2fmodexpdata/BlakeModexpData.java → arithmetization/src/main/java/net/consensys/linea/zktracer/module/blake2fmodexpdata/BlakeModexp.java

@@ -15,6 +15,7 @@
 
 package net.consensys.linea.zktracer.module.blake2fmodexpdata;
 
+import static com.google.common.base.Preconditions.checkState;
 import static net.consensys.linea.zktracer.module.ModuleName.BLAKE_MODEXP_DATA;
 
 import java.util.List;
@@ -28,21 +29,20 @@
 import net.consensys.linea.zktracer.container.module.OperationListModule;
 import net.consensys.linea.zktracer.container.stacked.ModuleOperationStackedList;
 import net.consensys.linea.zktracer.module.ModuleName;
-import net.consensys.linea.zktracer.module.hub.precompiles.ModexpMetadata;
 import net.consensys.linea.zktracer.module.limits.precompiles.BlakeRounds;
 import net.consensys.linea.zktracer.module.wcp.Wcp;
 
 @RequiredArgsConstructor
 @Getter
 @Accessors(fluent = true)
-public class BlakeModexpData implements OperationListModule<BlakeModexpDataOperation> {
+public abstract class BlakeModexp implements OperationListModule<BlakeModexpOperation> {
   private final Wcp wcp;
   private final IncrementAndDetectModule modexpEffectiveCall;
   private final IncrementingModule modexpLargeCall;
   private final IncrementingModule blakeEffectiveCall;
   private final BlakeRounds blakeRounds;
 
-  private final ModuleOperationStackedList<BlakeModexpDataOperation> operations =
+  private final ModuleOperationStackedList<BlakeModexpOperation> operations =
       new ModuleOperationStackedList<>();
 
   private long previousID = 0;
@@ -52,21 +52,26 @@ public ModuleName moduleKey() {
     return BLAKE_MODEXP_DATA;
   }
 
-  public void callModexp(final ModexpMetadata modexpMetaData, final int operationID) {
-    operations.add(new BlakeModexpDataOperation(modexpMetaData, operationID));
+  public void callModexp(BlakeModexpOperation modexpOperation) {
+
+    checkState(modexpOperation.isModexpOperation(), "Operation must be a MODEXP operation");
+    operations.add(modexpOperation);
+
     modexpEffectiveCall.updateTally(1);
-    modexpLargeCall.updateTally(modexpMetaData.largeModexp());
-    callWcpForIdCheck(operationID);
+    modexpLargeCall.updateTally(modexpOperation.modexpMetaData.get().largeModexp());
+    callWcpForIdCheck(modexpOperation.id());
   }
 
-  public void callBlake(final BlakeComponents blakeComponents, final int operationID) {
-    operations.add(new BlakeModexpDataOperation(blakeComponents, operationID));
+  public void callBlake(BlakeModexpOperation blakeOperation) {
+    checkState(blakeOperation.isBlakeOperation(), "Operation must be a BLAKE2f operation");
+    operations.add(blakeOperation);
+
     blakeEffectiveCall.updateTally(1);
-    blakeRounds.addPrecompileLimit(blakeComponents.r());
-    callWcpForIdCheck(operationID);
+    blakeRounds.addPrecompileLimit(blakeOperation.blake2fComponents.get().r());
+    callWcpForIdCheck(blakeOperation.id());
   }
 
-  private void callWcpForIdCheck(final int operationID) {
+  private void callWcpForIdCheck(final long operationID) {
     wcp.callLT(previousID, operationID);
     previousID = operationID;
   }
@@ -84,7 +89,7 @@ public int spillage(Trace trace) {
   @Override
   public void commit(Trace trace) {
     int stamp = 0;
-    for (BlakeModexpDataOperation o : operations.getAll()) {
+    for (BlakeModexpOperation o : operations.getAll()) {
       o.trace(trace.blake2fmodexpdata(), ++stamp);
     }
   }

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blake2fmodexpdata/BlakeModexpDataOperation.java → arithmetization/src/main/java/net/consensys/linea/zktracer/module/blake2fmodexpdata/BlakeModexpOperation.java

@@ -15,14 +15,7 @@
 
 package net.consensys.linea.zktracer.module.blake2fmodexpdata;
 
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_BLAKE_DATA;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_BLAKE_PARAMS;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_BLAKE_RESULT;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_MODEXP;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_MODEXP_BASE;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_MODEXP_EXPONENT;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_MODEXP_MODULUS;
-import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.INDEX_MAX_MODEXP_RESULT;
+import static net.consensys.linea.zktracer.Trace.Blake2fmodexpdata.*;
 import static net.consensys.linea.zktracer.Trace.LLARGE;
 import static net.consensys.linea.zktracer.Trace.PHASE_BLAKE_DATA;
 import static net.consensys.linea.zktracer.Trace.PHASE_BLAKE_PARAMS;
@@ -39,46 +32,58 @@
 import lombok.experimental.Accessors;
 import net.consensys.linea.zktracer.Trace;
 import net.consensys.linea.zktracer.container.ModuleOperation;
-import net.consensys.linea.zktracer.module.hub.precompiles.ModexpMetadata;
+import net.consensys.linea.zktracer.module.hub.precompiles.modexpMetadata.ModexpMetadata;
 import net.consensys.linea.zktracer.types.UnsignedByte;
 import org.apache.tuweni.bytes.Bytes;
 import org.hyperledger.besu.crypto.Hash;
 
 @Accessors(fluent = true)
-public class BlakeModexpDataOperation extends ModuleOperation {
-  public static final short MODEXP_COMPONENT_BYTE_SIZE = LLARGE * (INDEX_MAX_MODEXP + 1);
-  public static final short NB_ROWS_BLAKEMODEXP_MODEXP =
-      (INDEX_MAX_MODEXP_BASE + 1)
-          + (INDEX_MAX_MODEXP_EXPONENT + 1)
-          + (INDEX_MAX_MODEXP_MODULUS + 1)
-          + (INDEX_MAX_MODEXP_RESULT + 1);
-  public static final short NB_ROWS_BLAKEMODEPX_BLAKE =
-      (INDEX_MAX_BLAKE_DATA + 1) + (INDEX_MAX_BLAKE_PARAMS + 1) + (INDEX_MAX_BLAKE_RESULT + 1);
+public abstract class BlakeModexpOperation extends ModuleOperation {
   public static final short BLAKE2f_R_SIZE = 4;
   public static final short BLAKE2f_HASH_INPUT_OFFSET = BLAKE2f_R_SIZE;
   public static final short BLAKE2f_HASH_INPUT_SIZE = LLARGE * (INDEX_MAX_BLAKE_DATA + 1);
   public static final short BLAKE2f_HASH_OUTPUT_SIZE = LLARGE * (INDEX_MAX_BLAKE_RESULT + 1);
 
+  public static short numberOfRowsBlake() {
+    return (INDEX_MAX_BLAKE_DATA + 1) + (INDEX_MAX_BLAKE_PARAMS + 1) + (INDEX_MAX_BLAKE_RESULT + 1);
+  }
+
+  public abstract short getIndexMaxModexpBase();
+
+  public abstract short getIndexMaxModexpExponent();
+
+  public abstract short getIndexMaxModexpModulus();
+
+  public abstract short getIndexMaxModexpResult();
+
+  public short numberOfRowsModexp() {
+    return (short)
+        ((getIndexMaxModexpBase() + 1)
+            + (getIndexMaxModexpExponent() + 1)
+            + (getIndexMaxModexpModulus() + 1)
+            + (getIndexMaxModexpResult() + 1));
+  }
+
   @Getter public final long id;
 
   public final Optional<ModexpMetadata> modexpMetaData;
   public final Optional<BlakeComponents> blake2fComponents;
 
-  public BlakeModexpDataOperation(final ModexpMetadata modexpMetaData, final int id) {
+  public BlakeModexpOperation(final ModexpMetadata modexpMetaData, final int id) {
     this.id = id;
     this.modexpMetaData = Optional.of(modexpMetaData);
     this.blake2fComponents = Optional.empty();
   }
 
-  public BlakeModexpDataOperation(final BlakeComponents blakeComponents, final int id) {
+  public BlakeModexpOperation(final BlakeComponents blakeComponents, final int id) {
     this.id = id;
     this.modexpMetaData = Optional.empty();
     this.blake2fComponents = Optional.of(blakeComponents);
   }
 
   @Override
   protected int computeLineCount() {
-    return modexpMetaData.isPresent() ? NB_ROWS_BLAKEMODEXP_MODEXP : NB_ROWS_BLAKEMODEPX_BLAKE;
+    return modexpMetaData.isPresent() ? numberOfRowsModexp() : numberOfRowsBlake();
   }
 
   void trace(Trace.Blake2fmodexpdata trace, final int stamp) {
@@ -131,17 +136,19 @@ private void traceBlakeResult(Trace.Blake2fmodexpdata trace, int stamp) {
   }
 
   private void traceBase(Trace.Blake2fmodexpdata trace, final int stamp) {
-    final Bytes input = leftPadTo(modexpMetaData.get().base(), MODEXP_COMPONENT_BYTE_SIZE);
-    for (int index = 0; index <= INDEX_MAX_MODEXP_BASE; index++) {
-      commonTrace(trace, stamp, index, input, INDEX_MAX_MODEXP_BASE);
+    final Bytes input =
+        leftPadTo(modexpMetaData.get().base(), modexpMetaData.get().getMaxInputSize());
+    for (int index = 0; index <= getIndexMaxModexpBase(); index++) {
+      commonTrace(trace, stamp, index, input, getIndexMaxModexpBase());
       trace.phase(UnsignedByte.of(PHASE_MODEXP_BASE)).isModexpBase(true).fillAndValidateRow();
     }
   }
 
   private void traceExponent(Trace.Blake2fmodexpdata trace, final int stamp) {
-    final Bytes input = leftPadTo(modexpMetaData.get().exp(), MODEXP_COMPONENT_BYTE_SIZE);
-    for (int index = 0; index <= INDEX_MAX_MODEXP_EXPONENT; index++) {
-      commonTrace(trace, stamp, index, input, INDEX_MAX_MODEXP_EXPONENT);
+    final Bytes input =
+        leftPadTo(modexpMetaData.get().exp(), modexpMetaData.get().getMaxInputSize());
+    for (int index = 0; index <= getIndexMaxModexpExponent(); index++) {
+      commonTrace(trace, stamp, index, input, getIndexMaxModexpExponent());
       trace
           .phase(UnsignedByte.of(PHASE_MODEXP_EXPONENT))
           .isModexpExponent(true)
@@ -150,17 +157,19 @@ private void traceExponent(Trace.Blake2fmodexpdata trace, final int stamp) {
   }
 
   private void traceModulus(Trace.Blake2fmodexpdata trace, final int stamp) {
-    final Bytes input = leftPadTo(modexpMetaData.get().mod(), MODEXP_COMPONENT_BYTE_SIZE);
-    for (int index = 0; index <= INDEX_MAX_MODEXP_MODULUS; index++) {
-      commonTrace(trace, stamp, index, input, INDEX_MAX_MODEXP_MODULUS);
+    final Bytes input =
+        leftPadTo(modexpMetaData.get().mod(), modexpMetaData.get().getMaxInputSize());
+    for (int index = 0; index <= getIndexMaxModexpModulus(); index++) {
+      commonTrace(trace, stamp, index, input, getIndexMaxModexpModulus());
       trace.phase(UnsignedByte.of(PHASE_MODEXP_MODULUS)).isModexpModulus(true).fillAndValidateRow();
     }
   }
 
   private void traceModexpResult(Trace.Blake2fmodexpdata trace, final int stamp) {
-    final Bytes input = leftPadTo(modexpMetaData.get().rawResult(), MODEXP_COMPONENT_BYTE_SIZE);
-    for (int index = 0; index <= INDEX_MAX_MODEXP_RESULT; index++) {
-      commonTrace(trace, stamp, index, input, INDEX_MAX_MODEXP_RESULT);
+    final Bytes input =
+        leftPadTo(modexpMetaData.get().rawResult(), modexpMetaData.get().getMaxInputSize());
+    for (int index = 0; index <= getIndexMaxModexpResult(); index++) {
+      commonTrace(trace, stamp, index, input, getIndexMaxModexpResult());
       trace.phase(UnsignedByte.of(PHASE_MODEXP_RESULT)).isModexpResult(true).fillAndValidateRow();
     }
   }
@@ -178,4 +187,12 @@ private void commonTrace(
   private Bytes computeBlake2fResult() {
     return Hash.blake2bf(blake2fComponents.get().callData());
   }
+
+  public boolean isModexpOperation() {
+    return modexpMetaData.isPresent();
+  }
+
+  public boolean isBlakeOperation() {
+    return blake2fComponents.isPresent();
+  }
 }

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blake2fmodexpdata/LondonBlakeModexp.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright Consensys Software Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package net.consensys.linea.zktracer.module.blake2fmodexpdata;
+
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import net.consensys.linea.zktracer.container.module.IncrementAndDetectModule;
+import net.consensys.linea.zktracer.container.module.IncrementingModule;
+import net.consensys.linea.zktracer.module.limits.precompiles.BlakeRounds;
+import net.consensys.linea.zktracer.module.wcp.Wcp;
+
+@Getter
+@Accessors(fluent = true)
+public class LondonBlakeModexp extends BlakeModexp {
+  public LondonBlakeModexp(
+      Wcp wcp,
+      IncrementAndDetectModule modexpEffectiveCall,
+      IncrementingModule modexpLargeCall,
+      IncrementingModule blakeEffectiveCall,
+      BlakeRounds blakeRounds) {
+    super(wcp, modexpEffectiveCall, modexpLargeCall, blakeEffectiveCall, blakeRounds);
+  }
+}