doc: add error messages (#2365)

Signed-off-by: F Bojarski <[email protected]>
Co-authored-by: Olivier Bégassat <[email protected]>
Co-authored-by: Olivier Bégassat <[email protected]>

Author: letypequividelespoubelles

arithmetization/src/main/java/net/consensys/linea/zktracer/bytestheta/BytesArray.java

@@ -92,7 +92,7 @@ public MutableBytes get(int index) {
    * @param bytes the new Bytes value
    */
   public void set(int index, Bytes bytes) {
-    checkArgument(bytes.size() == 8);
+    checkArgument(bytes.size() == 8, "bytes size must be 8");
     bytesArray[index] = MutableBytes.wrap(bytes.toArray());
   }
 

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

@@ -65,7 +65,8 @@ public int spillage(Trace trace) {
   }
 
   public void updateTally(final int count) {
-    Preconditions.checkArgument(count >= 0, "Must be non-negative");
+    Preconditions.checkArgument(
+        count >= 0, "CountingOnlyModule: count %s in updateTally must be nonnegative", count);
     counts.add(count);
   }
 

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

@@ -29,7 +29,8 @@ public IncrementingModule(ModuleName moduleKey) {
   public void updateTally(final int numberEffectiveCall) {
     checkArgument(
         numberEffectiveCall == 0 || numberEffectiveCall == 1,
-        "Can only update the tally by one at the time.");
+        "IncrementingModule: updateTally can only update the tally by 0 or 1, here it's by %s",
+        numberEffectiveCall);
     counts.add(numberEffectiveCall);
   }
 

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

@@ -37,7 +37,8 @@ public void popTransactionBundle() {
   }
 
   public void add(final int operationCount) {
-    Preconditions.checkArgument(operationCount >= 0, "operationCount must be non negative");
+    Preconditions.checkArgument(
+        operationCount >= 0, "operationCount %s should be nonnegative", operationCount);
     countInTransactionBundle += operationCount;
   }
 

arithmetization/src/main/java/net/consensys/linea/zktracer/module/Util.java

@@ -117,7 +117,7 @@ public static boolean isUInt256(BigInteger number) {
    * @return The UInt256 sum of the products of the elements in the two input ranges.
    */
   public static UInt256 multiplyRange(Bytes[] range1, Bytes[] range2) {
-    checkArgument(range1.length == range2.length);
+    checkArgument(range1.length == range2.length, "Ranges must be of the same length");
     UInt256 sum = UInt256.ZERO;
     for (int i = 0; i < range1.length; i++) {
       UInt256 prod =

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blockdata/moduleOperation/BlockdataOperation.java

@@ -262,8 +262,8 @@ public void trace(Trace.Blockdata trace) {
 
   // Module call macros
   private boolean wcpCallTo(int w, EWord arg1, EWord arg2, int inst) {
-    checkArgument(arg1.bitLength() / 8 <= 32);
-    checkArgument(arg2.bitLength() / 8 <= 32);
+    checkArgument(arg1.bitLength() / 8 <= 32, "WCP: arg1 bit width too large");
+    checkArgument(arg2.bitLength() / 8 <= 32, "WCP: arg2 bit width too large");
 
     this.arg1[w] = arg1;
     this.arg2[w] = arg2;

arithmetization/src/main/java/net/consensys/linea/zktracer/module/blsdata/BlsDataOperation.java

@@ -129,7 +129,10 @@ private BlsDataOperation(
       Bytes callData,
       Bytes returnData,
       boolean successBit) {
-    checkArgument(precompileFlag.isBlsPrecompile(), "invalid BLS type");
+    checkArgument(
+        precompileFlag.isBlsPrecompile(),
+        "BlsDataOperation: precompile %s isn't of BLS type",
+        precompileFlag);
 
     this.precompileFlag = precompileFlag;
     this.callData = callData;
@@ -162,8 +165,12 @@ private BlsDataOperation(
     // Set successBit
     this.successBit = successBit;
     final int returnDataSize = returnData.toArray().length;
+    final int expectedReturnDataSize = (successBit ? expectedReturnDataSize(precompileFlag) : 0);
     Preconditions.checkArgument(
-        returnDataSize == (successBit ? expectedReturnDataSize(precompileFlag) : 0));
+        returnDataSize == expectedReturnDataSize,
+        "BLS precompile return data size %s does not agree with the expected value %s",
+        returnDataSize,
+        expectedReturnDataSize);
   }
 
   public static int expectedReturnDataSize(
@@ -250,7 +257,8 @@ private void handleBlsG1Add() {
       final boolean isSmallPointOnCurve =
           isSmallPointOnCurve(indexOffset, callData.slice(sizeOffset, SIZE_SMALL_POINT));
       final boolean mextBit = wellFormedCoordinate && !isSmallPointOnCurve;
-      Preconditions.checkArgument(mextBit == (wellFormedCoordinate && !successBit));
+      Preconditions.checkArgument(
+          mextBit == (wellFormedCoordinate && !successBit), "BLS_G1ADD: mext bit inconsistency");
 
       if (mextBit && !mextBitIsSet) {
         for (int j = 0; j <= CT_MAX_SMALL_POINT; j++) {
@@ -277,7 +285,8 @@ private void handleBlsG1Msm() {
       final boolean isSmallPointInSubgroup =
           isSmallPointInSubGroup(indexOffset, callData.slice(sizeOffset, SIZE_SMALL_POINT));
       final boolean mextBit = wellFormedCoordinate && !isSmallPointInSubgroup;
-      Preconditions.checkArgument(mextBit == (wellFormedCoordinate && !successBit));
+      Preconditions.checkArgument(
+          mextBit == (wellFormedCoordinate && !successBit), "BLS_G1MSM: mext bit inconsistency");
 
       if (mextBit && !mextBitIsSet) {
         for (int j = 0; j <= CT_MAX_SMALL_POINT; j++) {
@@ -307,7 +316,8 @@ private void handleBlsG2Add() {
       final boolean isLargePointOnCurve =
           isLargePointOnCurve(indexOffset, callData.slice(sizeOffset, SIZE_LARGE_POINT));
       final boolean mextBit = wellFormedCoordinate && !isLargePointOnCurve;
-      Preconditions.checkArgument(mextBit == (wellFormedCoordinate && !successBit));
+      Preconditions.checkArgument(
+          mextBit == (wellFormedCoordinate && !successBit), "BLS_G2ADD: mext bit inconsistency");
 
       if (mextBit && !mextBitIsSet) {
         for (int j = 0; j <= CT_MAX_LARGE_POINT; j++) {
@@ -338,7 +348,8 @@ private void handleBlsG2Msm() {
       final boolean isLargePointInSubgroup =
           isLargePointInSubGroup(indexOffset, callData.slice(sizeOffset, SIZE_LARGE_POINT));
       final boolean mextBit = wellFormedCoordinate && !isLargePointInSubgroup;
-      Preconditions.checkArgument(mextBit == (wellFormedCoordinate && !successBit));
+      Preconditions.checkArgument(
+          mextBit == (wellFormedCoordinate && !successBit), "BLS_G2MSM: mext bit inconsistency");
 
       if (mextBit && !mextBitIsSet) {
         for (int j = 0; j <= CT_MAX_LARGE_POINT; j++) {
@@ -371,7 +382,9 @@ private void handleBlsPairingCheck() {
       final boolean isSmallPointInSubgroup =
           isSmallPointInSubGroup(indexOffset, callData.slice(sizeOffset, SIZE_SMALL_POINT));
       final boolean mextBitSmall = wellFormedFpCoordinate && !isSmallPointInSubgroup;
-      Preconditions.checkArgument(mextBitSmall == (wellFormedFpCoordinate && !successBit));
+      Preconditions.checkArgument(
+          mextBitSmall == (wellFormedFpCoordinate && !successBit),
+          "BLS_PAIRING_CHECK: mext bit inconsistency for small point");
 
       if (mextBitSmall && !mextBitIsSet) {
         for (int j = 0; j <= CT_MAX_SMALL_POINT; j++) {
@@ -388,7 +401,9 @@ private void handleBlsPairingCheck() {
           isLargePointInSubGroup(
               8 + indexOffset, callData.slice(8 * LLARGE + sizeOffset, SIZE_LARGE_POINT));
       final boolean mextBitLarge = wellFormedFp2Coordinate && !isLargePointInSubgroup;
-      Preconditions.checkArgument(mextBitLarge == (wellFormedFp2Coordinate && !successBit));
+      Preconditions.checkArgument(
+          mextBitLarge == (wellFormedFp2Coordinate && !successBit),
+          "BLS_PAIRING_CHECK: mext bit inconsistency for large point");
 
       if (mextBitLarge && !mextBitIsSet) {
         for (int j = 0; j <= CT_MAX_LARGE_POINT; j++) {

arithmetization/src/main/java/net/consensys/linea/zktracer/module/ecdata/EcDataOperation.java

@@ -135,20 +135,26 @@ private EcDataOperation(
       final PrecompileScenarioFragment.PrecompileFlag precompileFlag,
       Bytes callData,
       Bytes returnData) {
-    checkArgument(precompileFlag.isEcdataPrecompile(), "invalid EC type");
+    checkArgument(
+        precompileFlag.isEcdataPrecompile(),
+        "EcDataOperation: precompile %s isn't of EC_DATA type",
+        precompileFlag);
 
     this.precompileFlag = precompileFlag;
     final int callDataSize = callData.size();
     checkArgument(
-        callDataSize > 0,
-        "EcDataOperation should only be called with nonempty call rightPaddedCallData");
+        callDataSize > 0, "EcDataOperation should only be called with nonempty call data");
     final int paddedCallDataLength =
         switch (precompileFlag) {
           case PRC_ECRECOVER -> TOTAL_SIZE_ECRECOVER_DATA;
           case PRC_ECADD -> TOTAL_SIZE_ECADD_DATA;
           case PRC_ECMUL -> TOTAL_SIZE_ECMUL_DATA;
           case PRC_ECPAIRING -> {
-            checkArgument(callDataSize % TOTAL_SIZE_ECPAIRING_DATA_MIN == 0);
+            checkArgument(
+                callDataSize % TOTAL_SIZE_ECPAIRING_DATA_MIN == 0,
+                "ECPAIRING: call data size expected to be multiple of %s, but remainder is %s ≠ 0",
+                TOTAL_SIZE_ECPAIRING_DATA_MIN,
+                callDataSize % TOTAL_SIZE_ECPAIRING_DATA_MIN);
             yield callDataSize;
           }
           default -> throw new IllegalArgumentException(
@@ -425,7 +431,10 @@ void handleAdd() {
 
     // Extract output
     if (internalChecksPassed && returnData.toArray().length != 0) {
-      checkArgument(returnData.toArray().length == 64);
+      checkArgument(
+          returnData.toArray().length == 64,
+          "ECADD: return data size %s should be 64",
+          returnData.toArray().length);
       resX = EWord.of(returnData.slice(0, 32));
       resY = EWord.of(returnData.slice(32, 32));
     }
@@ -473,7 +482,10 @@ void handleMul() {
 
     // Extract output
     if (internalChecksPassed && returnData.toArray().length != 0) {
-      checkArgument(returnData.toArray().length == 64);
+      checkArgument(
+          returnData.toArray().length == 64,
+          "ECMUL: return data size %s should be 64",
+          returnData.toArray().length);
       resX = EWord.of(returnData.slice(0, 32));
       resY = EWord.of(returnData.slice(32, 32));
     }
@@ -690,9 +702,16 @@ void trace(Trace.Ecdata trace, final int stamp, final long previousId) {
       }
 
       if (precompileFlag != PRC_ECPAIRING || !isData) {
-        checkArgument(ct == 0);
+        checkArgument(
+            ct == 0,
+            "EcDataOperation's trace method: ct should be 0 except for ECPAIRING data rows, yet prc = %s, isData = %s, ct = %s",
+            precompileFlag,
+            isData,
+            ct);
       }
-      checkArgument(!(isSmallPoint && isLargePoint));
+      checkArgument(
+          !(isSmallPoint && isLargePoint),
+          "EcDataOperation's trace: ECPAIRING data simultaneously categorized as small and large point");
 
       trace
           .stamp(stamp)

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

@@ -57,7 +57,9 @@ public ExpOperation(ExpCall expCall) {
         final ModexpMetadata modexpMetadata = modexplogExpCall.getModexpMetadata();
         final int bbsInt = modexpMetadata.bbsInt();
         final int ebsInt = modexpMetadata.ebsInt();
-        checkArgument(modexpMetadata.callData().size() - BASE_MIN_OFFSET - bbsInt >= 0);
+        checkArgument(
+            modexpMetadata.callData().size() - BASE_MIN_OFFSET - bbsInt >= 0,
+            "MODEXP call data unexpectedly short");
         final EWord rawLead = modexpMetadata.rawLeadingWord();
         final int cdsCutoff =
             Math.min(modexpMetadata.callData().size() - BASE_MIN_OFFSET - bbsInt, 32);

arithmetization/src/main/java/net/consensys/linea/zktracer/module/hub/AccountSnapshot.java

@@ -158,7 +158,7 @@ public AccountSnapshot deepCopy() {
 
   public void wipe(DeploymentInfo deploymentInfo) {
     final boolean deploymentStatus = deploymentInfo.getDeploymentStatus(address);
-    checkArgument(!deploymentStatus);
+    checkArgument(!deploymentStatus, "Cannot wipe an account that is under deployment");
     this.nonce(0).balance(Wei.ZERO).code(Bytecode.EMPTY).setDeploymentInfo(deploymentInfo);
   }
 
@@ -232,7 +232,10 @@ public AccountSnapshot raiseNonceByOne() {
   }
 
   public AccountSnapshot decrementNonceByOne() {
-    checkState(nonce > 0);
+    checkState(
+        nonce > 0,
+        "AccountSnapshot: attempting to decrement nonce by one when nonce is %s ≤ 0",
+        nonce);
     return this.nonce(nonce - 1);
   }
 
@@ -245,7 +248,10 @@ public AccountSnapshot setDeploymentNumber(DeploymentInfo deploymentInfo) {
   }
 
   public void decrementDeploymentNumberByOne() {
-    checkState(deploymentNumber > 0);
+    checkState(
+        deploymentNumber > 0,
+        "Attempting to decrement deployment number by one when deployment number is %s ≤ 0",
+        deploymentNumber);
     this.deploymentNumber(deploymentNumber - 1);
   }