feat: make the trace deterministic

arithmetization/src/main/java/net/consensys/linea/zktracer/container/module/OperationSetModule.java

@@ -15,6 +15,9 @@
 
 package net.consensys.linea.zktracer.container.module;
 
+import java.util.Comparator;
+import java.util.List;
+
 import net.consensys.linea.zktracer.container.ModuleOperation;
 import net.consensys.linea.zktracer.container.stacked.ModuleOperationStackedSet;
 import org.hyperledger.besu.evm.worldstate.WorldView;
@@ -46,4 +49,8 @@ default int lineCount() {
   default void traceEndConflation(final WorldView state) {
     operations().finishConflation();
   }
+
+  default List<E> sortOperations(Comparator<E> comparator) {
+    return operations().sortOperations(comparator);
+  }
 }

arithmetization/src/main/java/net/consensys/linea/zktracer/container/stacked/ModuleOperationStackedSet.java

@@ -15,7 +15,10 @@
 
 package net.consensys.linea.zktracer.container.stacked;
 
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
 import java.util.Set;
 
 import com.google.common.base.Preconditions;
@@ -135,4 +138,10 @@ public void finishConflation() {
     operationsInTransaction().clear();
     lineCounter.enter(); // this is not mandatory but it is more consistent
   }
+
+  public List<E> sortOperations(Comparator<E> comparator) {
+    final List<E> sortedOperations = new ArrayList<>(getAll());
+    sortedOperations.sort(comparator);
+    return sortedOperations;
+  }
 }

arithmetization/src/main/java/net/consensys/linea/zktracer/module/add/Add.java

@@ -62,7 +62,7 @@ public List<ColumnHeader> columnsHeaders() {
   public void commit(List<MappedByteBuffer> buffers) {
     final Trace trace = new Trace(buffers);
     int stamp = 0;
-    for (AddOperation op : operations.getAll()) {
+    for (AddOperation op : sortOperations(new AddOperationComparator())) {
       op.trace(++stamp, trace);
     }
   }

arithmetization/src/main/java/net/consensys/linea/zktracer/module/add/AddOperation.java

@@ -18,6 +18,8 @@
 import static net.consensys.linea.zktracer.module.constants.GlobalConstants.LLARGE;
 
 import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.experimental.Accessors;
 import net.consensys.linea.zktracer.bytestheta.BaseBytes;
 import net.consensys.linea.zktracer.container.ModuleOperation;
 import net.consensys.linea.zktracer.opcode.OpCode;
@@ -27,13 +29,14 @@
 import org.apache.tuweni.bytes.Bytes32;
 import org.apache.tuweni.units.bigints.UInt256;
 
+@Accessors(fluent = true)
 @EqualsAndHashCode(onlyExplicitlyIncluded = true, callSuper = false)
 public final class AddOperation extends ModuleOperation {
   private static final UInt256 TWO_TO_THE_128 = UInt256.ONE.shiftLeft(128);
 
-  @EqualsAndHashCode.Include private final OpCode opCode;
-  @EqualsAndHashCode.Include private final Bytes32 arg1;
-  @EqualsAndHashCode.Include private final Bytes32 arg2;
+  @EqualsAndHashCode.Include @Getter private final OpCode opCode;
+  @EqualsAndHashCode.Include @Getter private final Bytes32 arg1;
+  @EqualsAndHashCode.Include @Getter private final Bytes32 arg2;
   private BaseBytes res;
   private int ctMax;
 

arithmetization/src/main/java/net/consensys/linea/zktracer/module/add/AddOperationComparator.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright ConsenSys 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.add;
+
+import java.util.Comparator;
+
+public class AddOperationComparator implements Comparator<AddOperation> {
+  public int compare(AddOperation op1, AddOperation op2) {
+    // First sort by OpCode
+    final int opCodeComp = op1.opCode().compareTo(op2.opCode());
+    if (opCodeComp != 0) {
+      return opCodeComp;
+    }
+    // Second sort by Arg1
+    final int arg1Comp = op1.arg1().compareTo(op2.arg1());
+    if (arg1Comp != 0) {
+      return arg1Comp;
+    }
+    // Third, sort by Arg2
+    return op1.arg2().compareTo(op2.arg2());
+  }
+}

arithmetization/src/main/java/net/consensys/linea/zktracer/module/bin/Bin.java

@@ -60,7 +60,7 @@ public void commit(List<MappedByteBuffer> buffers) {
     final Trace trace = new Trace(buffers);
 
     int stamp = 0;
-    for (BinOperation op : operations.getAll()) {
+    for (BinOperation op : operations.sortOperations(new BinOperationComparator())) {
       op.traceBinOperation(++stamp, trace);
     }
   }

arithmetization/src/main/java/net/consensys/linea/zktracer/module/bin/BinOperationComparator.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright ConsenSys 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.bin;
+
+import java.util.Comparator;
+
+public class BinOperationComparator implements Comparator<BinOperation> {
+  public int compare(BinOperation op1, BinOperation op2) {
+    // First sort by OpCode
+    final int opCodeComp = op1.opCode().compareTo(op2.opCode());
+    if (opCodeComp != 0) {
+      return opCodeComp;
+    }
+    // Second sort by Arg1
+    final int arg1Comp = op1.arg1().getBytes32().compareTo(op2.arg1().getBytes32());
+    if (arg1Comp != 0) {
+      return arg1Comp;
+    }
+    // Third, sort by Arg2
+    return op1.arg2().getBytes32().compareTo(op2.arg2().getBytes32());
+  }
+}

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blockhash/Blockhash.java

@@ -20,7 +20,6 @@
 import static net.consensys.linea.zktracer.module.constants.GlobalConstants.LLARGE;
 
 import java.nio.MappedByteBuffer;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -87,19 +86,19 @@ public void tracePreOpcode(MessageFrame frame) {
 
     opcodeArgument = Bytes32.leftPad(frame.getStackItem(0));
     lowerBound =
-        this.wcp.callGEQ(
-            opcodeArgument, Bytes.ofUnsignedLong(this.absoluteBlockNumber - BLOCKHASH_MAX_HISTORY));
-    upperBound = this.wcp.callLT(opcodeArgument, Bytes.ofUnsignedLong(this.absoluteBlockNumber));
+        wcp.callGEQ(
+            opcodeArgument, Bytes.ofUnsignedLong(absoluteBlockNumber - BLOCKHASH_MAX_HISTORY));
+    upperBound = wcp.callLT(opcodeArgument, Bytes.ofUnsignedLong(absoluteBlockNumber));
 
     hub.defers().scheduleForPostExecution(this);
 
     /* To prove the lex order of BLOCK_NUMBER_HI/LO, we call WCP at endConflation, so we need to add rows in WCP now.
     If a BLOCK_NUMBER is already called at least two times, no need for additional rows in WCP*/
-    final int numberOfCall = this.numberOfCall.getOrDefault(this.opcodeArgument, 0);
+    final int numberOfCall = this.numberOfCall.getOrDefault(opcodeArgument, 0);
     if (numberOfCall < 2) {
       wcp.additionalRows.add(
-          Math.max(Math.min(LLARGE, this.opcodeArgument.trimLeadingZeros().size()), 1));
-      this.numberOfCall.replace(this.opcodeArgument, numberOfCall, numberOfCall + 1);
+          Math.max(Math.min(LLARGE, opcodeArgument.trimLeadingZeros().size()), 1));
+      this.numberOfCall.replace(opcodeArgument, numberOfCall, numberOfCall + 1);
     }
   }
 
@@ -111,25 +110,18 @@ public void resolvePostExecution(
       final Bytes32 result = Bytes32.leftPad(frame.getStackItem(0));
       operations.add(
           new BlockhashOperation(
-              this.relativeBlock,
-              this.opcodeArgument,
-              this.absoluteBlockNumber,
-              lowerBound,
-              upperBound,
-              result));
+              relativeBlock, opcodeArgument, absoluteBlockNumber, lowerBound, upperBound, result));
       if (result != Bytes32.ZERO) {
-        blockHashMap.put(this.opcodeArgument, result);
+        blockHashMap.put(opcodeArgument, result);
       }
     }
   }
 
   @Override
   public void traceEndConflation(WorldView state) {
     OperationSetModule.super.traceEndConflation(state);
-    sortedOperations = new ArrayList<>(operations.getAll());
+    sortedOperations = sortOperations(new BlockhashComparator());
     if (!sortedOperations.isEmpty()) {
-      final BlockhashComparator BLOCKHASH_COMPARATOR = new BlockhashComparator();
-      sortedOperations.sort(BLOCKHASH_COMPARATOR);
       wcp.callGEQ(sortedOperations.getFirst().opcodeArgument(), Bytes32.ZERO);
       for (int i = 1; i < sortedOperations.size(); i++) {
         wcp.callGEQ(

arithmetization/src/main/java/net/consensys/linea/zktracer/module/euc/Euc.java

@@ -52,7 +52,7 @@ public List<ColumnHeader> columnsHeaders() {
   @Override
   public void commit(List<MappedByteBuffer> buffers) {
     final Trace trace = new Trace(buffers);
-    for (EucOperation eucOperation : operations.getAll()) {
+    for (EucOperation eucOperation : operations.sortOperations(new EucOperationComparator())) {
       eucOperation.trace(trace);
     }
   }

arithmetization/src/main/java/net/consensys/linea/zktracer/module/euc/EucOperationComparator.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright ConsenSys 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.euc;
+
+import java.util.Comparator;
+
+public class EucOperationComparator implements Comparator<EucOperation> {
+  public int compare(EucOperation op1, EucOperation op2) {
+    // Second sort by Dividend
+    final int arg1Comp = op1.dividend().compareTo(op2.dividend());
+    if (arg1Comp != 0) {
+      return arg1Comp;
+    } else {
+      // Second, sort by Divisor
+      return op1.divisor().compareTo(op2.divisor());
+    }
+  }
+}

arithmetization/src/main/java/net/consensys/linea/zktracer/module/exp/Exp.java

@@ -59,7 +59,7 @@ public void commit(List<MappedByteBuffer> buffers) {
     final Trace trace = new Trace(buffers);
 
     int stamp = 0;
-    for (ExpOperation expOp : operations.getAll()) {
+    for (ExpOperation expOp : operations.sortOperations(new ExpOperationComparator())) {
       expOp.traceComputation(++stamp, trace);
       expOp.traceMacro(stamp, trace);
       expOp.tracePreprocessing(stamp, trace);

arithmetization/src/main/java/net/consensys/linea/zktracer/module/exp/ExpOperation.java

@@ -36,6 +36,7 @@
 
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.experimental.Accessors;
 import net.consensys.linea.zktracer.container.ModuleOperation;
 import net.consensys.linea.zktracer.module.constants.GlobalConstants;
 import net.consensys.linea.zktracer.module.hub.Hub;
@@ -48,7 +49,9 @@
 import net.consensys.linea.zktracer.types.UnsignedByte;
 import org.apache.tuweni.bytes.Bytes;
 
+@EqualsAndHashCode(onlyExplicitlyIncluded = true, callSuper = false)
 @Getter
+@Accessors(fluent = true)
 public class ExpOperation extends ModuleOperation {
   @EqualsAndHashCode.Include ExpCall expCall;
 
@@ -90,8 +93,8 @@ public ExpOperation(ExpCall expCall, Wcp wcp, Hub hub) {
       long dynCost = (long) GlobalConstants.GAS_CONST_G_EXP_BYTE * exponent.byteLength();
 
       // Fill expCall
-      explogExpCall.setExponent(exponent);
-      explogExpCall.setDynCost(dynCost);
+      explogExpCall.exponent(exponent);
+      explogExpCall.dynCost(dynCost);
 
       // Execute preprocessing
       preComputeForExplog(explogExpCall);
@@ -100,7 +103,7 @@ public ExpOperation(ExpCall expCall, Wcp wcp, Hub hub) {
       ModexpLogExpCall modexplogExpCall = (ModexpLogExpCall) expCall;
 
       // Extract inputs
-      ModexpMetadata modexpMetadata = modexplogExpCall.getModexpMetadata();
+      final ModexpMetadata modexpMetadata = modexplogExpCall.getModexpMetadata();
       final int bbsInt = modexpMetadata.bbs().toUnsignedBigInteger().intValueExact();
       final int ebsInt = modexpMetadata.ebs().toUnsignedBigInteger().intValueExact();
       checkArgument(modexpMetadata.callData().size() - 96 - bbsInt >= 0);
@@ -123,28 +126,28 @@ public ExpOperation(ExpCall expCall, Wcp wcp, Hub hub) {
 
   public void preComputeForExplog(ExplogExpCall explogExpCall) {
     pMacroExpInst = EXP_INST_EXPLOG;
-    pMacroData1 = explogExpCall.getExponent().hi();
-    pMacroData2 = explogExpCall.getExponent().lo();
-    pMacroData5 = Bytes.ofUnsignedLong(explogExpCall.getDynCost());
+    pMacroData1 = explogExpCall.exponent().hi();
+    pMacroData2 = explogExpCall.exponent().lo();
+    pMacroData5 = Bytes.ofUnsignedLong(explogExpCall.dynCost());
     initArrays(CT_MAX_PRPRC_EXP_LOG + 1);
 
     // Preprocessing
     // First row
     pPreprocessingWcpFlag[0] = true;
     pPreprocessingWcpArg1Hi[0] = Bytes.EMPTY;
-    pPreprocessingWcpArg1Lo[0] = explogExpCall.getExponent().hi();
+    pPreprocessingWcpArg1Lo[0] = explogExpCall.exponent().hi();
     pPreprocessingWcpArg2Hi[0] = Bytes.EMPTY;
     pPreprocessingWcpArg2Lo[0] = Bytes.EMPTY;
     pPreprocessingWcpInst[0] = UnsignedByte.of(EVM_INST_ISZERO);
-    final boolean expnHiIsZero = wcp.callISZERO(explogExpCall.getExponent().hi());
+    final boolean expnHiIsZero = wcp.callISZERO(explogExpCall.exponent().hi());
     ;
     pPreprocessingWcpRes[0] = expnHiIsZero;
 
     // Linking constraints and fill rawAcc
     pComputationPltJmp = 16;
-    pComputationRawAcc = explogExpCall.getExponent().hi();
+    pComputationRawAcc = explogExpCall.exponent().hi();
     if (expnHiIsZero) {
-      pComputationRawAcc = explogExpCall.getExponent().lo();
+      pComputationRawAcc = explogExpCall.exponent().lo();
     }
 
     // Fill trimAcc

arithmetization/src/main/java/net/consensys/linea/zktracer/module/exp/ExpOperationComparator.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright ConsenSys 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.exp;
+
+import java.util.Comparator;
+
+public class ExpOperationComparator implements Comparator<ExpOperation> {
+  @Override
+  public int compare(ExpOperation op1, ExpOperation op2) {
+    final int instructionComp =
+        Integer.compare(op1.expCall().expInstruction(), op2.expCall().expInstruction());
+    if (instructionComp != 0) {
+      return instructionComp;
+    }
+
+    return op1.expCall.compareTo(op2.expCall);
+  }
+}

arithmetization/src/main/java/net/consensys/linea/zktracer/module/ext/Ext.java

@@ -84,7 +84,7 @@ public void commit(List<MappedByteBuffer> buffers) {
     final Trace trace = new Trace(buffers);
 
     int stamp = 0;
-    for (ExtOperation operation : operations.getAll()) {
+    for (ExtOperation operation : operations.sortOperations(new ExtOperationComparator())) {
       operation.trace(trace, ++stamp);
     }
   }