feat: trace all previous blockhashes

arithmetization/src/main/java/net/consensys/linea/blockcapture/BlockCapturer.java

@@ -16,6 +16,7 @@
 package net.consensys.linea.blockcapture;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.google.gson.Gson;
@@ -40,10 +41,6 @@
 import org.hyperledger.besu.plugin.data.BlockHeader;
 
 public class BlockCapturer implements ConflationAwareOperationTracer {
-  public static final int MAX_RELATIVE_BLOCK = 256;
-
-  private static final int MAX_BLOCK_ARG_SIZE = 8;
-
   /**
    * The {@link Reaper} will collect all the data that will need to be mimicked to replay the block.
    */
@@ -60,12 +57,14 @@ public class BlockCapturer implements ConflationAwareOperationTracer {
 
   /**
    * Construct a BlockCapturer instance for a specific fork. This is necessary to ensure opcodes are
-   * loaded before hand.
+   * loaded beforehand.
    *
    * @param fork
    */
-  public BlockCapturer(Fork fork) {
-    this.opcodes = OpCodes.load(fork);
+  public BlockCapturer(Fork fork, Map<Long, Hash> historicalBlockHashes) {
+    opcodes = OpCodes.load(fork);
+    for (Map.Entry<Long, Hash> entry : historicalBlockHashes.entrySet())
+      reaper.touchBlockHash(entry.getKey(), entry.getValue());
   }
 
   /**
@@ -89,12 +88,19 @@ public void traceStartBlock(
       BlockHeader blockHeader,
       BlockBody blockBody,
       final Address miningBeneficiary) {
-    this.reaper.enterBlock(blockHeader, blockBody, miningBeneficiary);
+    reaper.enterBlock(blockHeader, blockBody, miningBeneficiary);
+  }
+
+  // used to record the block hash of the last block in the conflation (previous one are already
+  // recorded in the constructor)
+  @Override
+  public void traceEndBlock(final BlockHeader blockHeader, final BlockBody blockBody) {
+    reaper.touchBlockHash(blockHeader.getNumber(), blockHeader.getBlockHash());
   }
 
   @Override
   public void tracePrepareTransaction(WorldView worldView, Transaction transaction) {
-    this.reaper.prepareTransaction(transaction);
+    reaper.prepareTransaction(transaction);
   }
 
   @Override
@@ -107,7 +113,7 @@ public void traceEndTransaction(
       long gasUsed,
       Set<Address> selfDestructs,
       long timeNs) {
-    this.reaper.exitTransaction(world, status, output, logs, gasUsed, selfDestructs);
+    reaper.exitTransaction(world, status, output, logs, gasUsed, selfDestructs);
   }
 
   /**
@@ -125,7 +131,7 @@ public void tracePreExecution(MessageFrame frame) {
       case EXTCODESIZE, EXTCODECOPY, EXTCODEHASH -> {
         if (frame.stackSize() > 0) {
           final Address target = Words.toAddress(frame.getStackItem(0));
-          this.reaper.touchAddress(target);
+          reaper.touchAddress(target);
         }
       }
 
@@ -135,7 +141,7 @@ public void tracePreExecution(MessageFrame frame) {
           final Account account = frame.getWorldUpdater().get(frame.getRecipientAddress());
           final Address address = account.getAddress();
           final UInt256 key = UInt256.fromBytes(frame.getStackItem(0));
-          this.reaper.touchStorage(address, key);
+          reaper.touchStorage(address, key);
         }
       }
 
@@ -145,65 +151,45 @@ public void tracePreExecution(MessageFrame frame) {
           final Account account = frame.getWorldUpdater().get(frame.getRecipientAddress());
           final Address address = account.getAddress();
           final UInt256 key = UInt256.fromBytes(frame.getStackItem(0));
-          this.reaper.touchStorage(address, key);
+          reaper.touchStorage(address, key);
         }
       }
 
         // These access contracts potentially existing before the conflation played out.
       case CALL, CALLCODE, DELEGATECALL, STATICCALL -> {
         if (frame.stackSize() > 1) {
           final Address target = Words.toAddress(frame.getStackItem(1));
-          this.reaper.touchAddress(target);
+          reaper.touchAddress(target);
         }
       }
 
       case BALANCE -> {
         if (frame.stackSize() > 0) {
           final Address target = Words.toAddress(frame.getStackItem(0));
-          this.reaper.touchAddress(target);
+          reaper.touchAddress(target);
         }
       }
 
         // Failure condition if created address already exists
       case CREATE, CREATE2 -> {
         if (frame.stackSize() > 0) {
           final Address target = AddressUtils.getDeploymentAddress(frame, opCode);
-          this.reaper.touchAddress(target);
+          reaper.touchAddress(target);
         }
       }
 
         // Funds of the selfdestruct account are sent to the target account
       case SELFDESTRUCT -> {
         if (frame.stackSize() > 0) {
           final Address target = Words.toAddress(frame.getStackItem(0));
-          this.reaper.touchAddress(target);
-        }
-      }
-
-      case BLOCKHASH -> {
-        if (frame.stackSize() > 0) {
-          // Determine current block number
-          final long currentBlockNumber = frame.getBlockValues().getNumber();
-          final Bytes arg = frame.getStackItem(0).trimLeadingZeros();
-          // Check arguments fits within 8 bytes
-          if (arg.size() <= 8) {
-            // Determine block number requested
-            final long blockNumber = arg.toLong();
-            // Sanity check block within last 256 blocks.
-            if (blockNumber < currentBlockNumber && (currentBlockNumber - blockNumber) <= 256) {
-              // Use enclosing frame to determine hash
-              Hash blockHash = frame.getBlockHashLookup().apply(frame, blockNumber);
-              // Record it was seen
-              this.reaper.touchBlockHash(blockNumber, blockHash);
-            }
-          }
+          reaper.touchAddress(target);
         }
       }
     }
   }
 
   public String toJson() {
     Gson gson = new Gson();
-    return gson.toJson(this.reaper.collapse(this.worldUpdater));
+    return gson.toJson(reaper.collapse(worldUpdater));
   }
 }

arithmetization/src/main/java/net/consensys/linea/blockcapture/reapers/Reaper.java

@@ -15,12 +15,16 @@
 
 package net.consensys.linea.blockcapture.reapers;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
+import static com.google.common.base.Preconditions.checkArgument;
+import static net.consensys.linea.zktracer.Trace.HISTORY_BUFFER_LENGTH;
+import static net.consensys.linea.zktracer.Trace.HISTORY_SERVE_WINDOW;
+import static net.consensys.linea.zktracer.module.hub.section.systemTransaction.EIP2935HistoricalHash.EIP2935_HISTORY_STORAGE_ADDRESS;
+import static net.consensys.linea.zktracer.module.hub.section.systemTransaction.EIP4788BeaconBlockRootSection.EIP4788_BEACONROOT_ADDRESS;
 
+import java.util.*;
+
+import lombok.extern.slf4j.Slf4j;
 import net.consensys.linea.blockcapture.snapshots.AccountSnapshot;
-import net.consensys.linea.blockcapture.snapshots.BlockHashSnapshot;
 import net.consensys.linea.blockcapture.snapshots.BlockSnapshot;
 import net.consensys.linea.blockcapture.snapshots.ConflationSnapshot;
 import net.consensys.linea.blockcapture.snapshots.StorageSnapshot;
@@ -44,6 +48,7 @@
  * <p>This data can than be collapsed into a “replay” ({@link ConflationSnapshot}), i.e. the minimal
  * required information to replay a conflation as if it were executed on the blockchain.
  */
+@Slf4j
 public class Reaper {
   /** Collect storage locations read / written by the entire conflation */
   private final StorageReaper conflationStorage = new StorageReaper();
@@ -52,7 +57,7 @@ public class Reaper {
   private final AddressReaper conflationAddresses = new AddressReaper();
 
   /** Collection all block hashes read during the conflation * */
-  private final BlockHashReaper conflationHashes = new BlockHashReaper();
+  private final Map<Long, Hash> conflationHashes = new HashMap<>();
 
   /** Collect the blocks within a conflation */
   private final List<BlockSnapshot> blocks = new ArrayList<>();
@@ -75,6 +80,38 @@ public void enterBlock(
         BlockSnapshot.of((org.hyperledger.besu.ethereum.core.BlockHeader) header, body));
     this.conflationAddresses.touch(miningBeneficiary);
     txIndex = 0; // reset
+    touchedBySystemTransactions(header);
+  }
+
+  private void touchedBySystemTransactions(BlockHeader header) {
+    // EIP 4788 (CANCUN):
+    try {
+      conflationAddresses.touch(EIP4788_BEACONROOT_ADDRESS);
+      final UInt256 timestamp = UInt256.valueOf(header.getTimestamp());
+      final UInt256 keyTimestamp = timestamp.mod(HISTORY_BUFFER_LENGTH);
+      conflationStorage.touch(EIP4788_BEACONROOT_ADDRESS, timestamp);
+      conflationStorage.touch(EIP4788_BEACONROOT_ADDRESS, keyTimestamp);
+    } catch (Exception e) {
+      log.warn(
+          "Failed to retrieve EIP4788 infos for block {}, exception caught is: {}",
+          header.getNumber(),
+          e.getMessage());
+    }
+
+    // EIP 2935 (PRAGUE)
+    try {
+      conflationAddresses.touch(EIP2935_HISTORY_STORAGE_ADDRESS);
+      final long blockNumber = header.getNumber();
+      final long previousBlockNumber = blockNumber == 0 ? 0 : blockNumber - 1;
+      final UInt256 previousBlockNumberMod8191 =
+          UInt256.valueOf(previousBlockNumber % HISTORY_SERVE_WINDOW);
+      conflationStorage.touch(EIP2935_HISTORY_STORAGE_ADDRESS, previousBlockNumberMod8191);
+    } catch (Exception e) {
+      log.warn(
+          "Failed to retrieve EIP2935 infos for block {}, exception caught is: {}",
+          header.getNumber(),
+          e.getMessage());
+    }
   }
 
   public void prepareTransaction(Transaction tx) {
@@ -96,7 +133,7 @@ public void exitTransaction(
     TransactionSnapshot txSnapshot = blocks.getLast().txs().get(txIndex);
     // Convert logs into hex strings
     List<String> logStrings = logs.stream().map(l -> l.getData().toHexString()).toList();
-    // Convert destructed account addresses into into hex strings
+    // Convert destructed account addresses into hex strings
     List<String> destructStrings = selfDestructs.stream().map(Address::toHexString).toList();
     // Collapse accounts
     final List<AccountSnapshot> accounts = this.txAddresses.collapse(world);
@@ -125,8 +162,16 @@ public void touchStorage(final Address address, final UInt256 key) {
   }
 
   public void touchBlockHash(final long blockNumber, Hash blockHash) {
-    this.conflationHashes.touch(blockNumber, blockHash);
-    // No need to tx local hashes, since they are a global concept.
+    if (!conflationHashes.containsKey(blockNumber) || conflationHashes.get(blockNumber).isEmpty()) {
+      conflationHashes.put(blockNumber, blockHash);
+    } else {
+      checkArgument(
+          conflationHashes.get(blockNumber).equals(blockHash),
+          "Block hash mismatch for block number %s: existing %s, new %s",
+          blockNumber,
+          conflationHashes.get(blockNumber),
+          blockHash);
+    }
   }
 
   /**
@@ -139,12 +184,10 @@ public void touchBlockHash(final long blockNumber, Hash blockHash) {
    */
   public ConflationSnapshot collapse(final WorldUpdater world) {
     // Collapse accounts
-    final List<AccountSnapshot> accounts = this.conflationAddresses.collapse(world);
+    final List<AccountSnapshot> accounts = conflationAddresses.collapse(world);
     // Collapse storage
     final List<StorageSnapshot> storage = conflationStorage.collapse(world);
-    // Collapse block hashes
-    final List<BlockHashSnapshot> hashes = conflationHashes.collapse();
     // Done
-    return new ConflationSnapshot(this.blocks, accounts, storage, hashes);
+    return ConflationSnapshot.from(blocks, accounts, storage, conflationHashes);
   }
 }

arithmetization/src/main/java/net/consensys/linea/blockcapture/snapshots/BlockHeaderSnapshot.java

@@ -46,7 +46,7 @@ public record BlockHeaderSnapshot(
     String mixHashOrPrevRandao,
     long nonce,
     Optional<String> baseFee,
-    Bytes32 parentBeaconBlockRoot) {
+    Optional<String> parentBeaconBlockRoot) {
   public static BlockHeaderSnapshot from(BlockHeader header) {
     return new BlockHeaderSnapshot(
         header.getParentHash().toHexString(),
@@ -65,7 +65,7 @@ public static BlockHeaderSnapshot from(BlockHeader header) {
         header.getMixHashOrPrevRandao().toHexString(),
         header.getNonce(),
         header.getBaseFee().map(Quantity::toHexString),
-        header.getParentBeaconBlockRoot().orElse(null));
+        header.getParentBeaconBlockRoot().map(Bytes::toHexString));
   }
 
   public BlockHeader toBlockHeader() {
@@ -87,11 +87,15 @@ public BlockHeader toBlockHeader() {
             .mixHash(Hash.fromHexString(this.mixHashOrPrevRandao))
             .prevRandao(Bytes32.fromHexString(this.mixHashOrPrevRandao))
             .nonce(this.nonce)
-            .blockHeaderFunctions(new CliqueBlockHeaderFunctions())
-            .parentBeaconBlockRoot(parentBeaconBlockRoot);
+            .blockHeaderFunctions(new CliqueBlockHeaderFunctions());
 
     this.baseFee.ifPresent(baseFee -> builder.baseFee(Wei.fromHexString(baseFee)));
-
+    // Following null check appears to be necessary for older replays.
+    if (this.parentBeaconBlockRoot != null) {
+      this.parentBeaconBlockRoot.ifPresent(
+          root -> builder.parentBeaconBlockRoot(Bytes32.fromHexString(root)));
+    }
+    //
     return builder.buildBlockHeader();
   }
 }