Merge nitro v2.3.4 (rc3)

Dockerfile

@@ -202,6 +202,7 @@ COPY ./scripts/download-machine.sh .
 #RUN ./download-machine.sh consensus-v10.3 0xf559b6d4fa869472dabce70fe1c15221bdda837533dfd891916836975b434dec
 #RUN ./download-machine.sh consensus-v11 0xf4389b835497a910d7ba3ebfb77aa93da985634f3c052de1290360635be40c4a
 #RUN ./download-machine.sh consensus-v11.1 0x68e4fe5023f792d4ef584796c84d710303a5e12ea02d6e37e2b5e9c4332507c4
+#RUN ./download-machine.sh consensus-v20 0x8b104a2e80ac6165dc58b9048de12f301d70b02a0ab51396c22b4b4b802a16a4
 
 RUN mkdir 0x965a35130f4e34b7b2339eac03b2eacc659e2dafe850d213ea6a7cdf9edfa99f && \
     ln -sfT 0x965a35130f4e34b7b2339eac03b2eacc659e2dafe850d213ea6a7cdf9edfa99f latest && \

arbitrator/jit/Cargo.toml

@@ -21,6 +21,7 @@ hex = "0.4.3"
 structopt = "0.3.26"
 sha3 = "0.9.1"
 libc = "0.2.132"
+sha2 = "0.9.9"
 
 [features]
 llvm = ["dep:wasmer-compiler-llvm"]

arbitrator/jit/src/wavmio.rs

@@ -8,6 +8,8 @@ use crate::{
 };
 use arbutil::{Color, PreimageType};
 use caller_env::{GuestPtr, MemAccess};
+use sha2::Sha256;
+use sha3::{Digest, Keccak256};
 use std::{
     io,
     io::{BufReader, BufWriter, ErrorKind},
@@ -168,6 +170,21 @@ pub fn resolve_preimage_impl(
         error!("Missing requested preimage for hash {hash_hex} in {name}")
     };
 
+    // Check if preimage rehashes to the provided hash. Exclude blob preimages
+    let calculated_hash: [u8; 32] = match preimage_type {
+        PreimageType::Keccak256 => Keccak256::digest(preimage).into(),
+        PreimageType::Sha2_256 => Sha256::digest(preimage).into(),
+        PreimageType::EthVersionedHash => *hash,
+    };
+    if calculated_hash != *hash {
+        error!(
+            "Calculated hash {} of preimage {} does not match provided hash {}",
+            hex::encode(calculated_hash),
+            hex::encode(preimage),
+            hex::encode(*hash)
+        );
+    }
+
     if offset % 32 != 0 {
         error!("bad offset {offset} in {name}")
     };

arbitrator/prover/Cargo.toml

@@ -38,6 +38,7 @@ num-derive = "0.4.1"
 num-traits = "0.2.17"
 c-kzg = { version = "0.4.0", optional = true } # TODO: look into switching to rust-kzg (no crates.io release or hosted rustdoc yet)
 sha2 = "0.9.9"
+lru = "0.12.3"
 
 [lib]
 name = "prover"

arbitrator/prover/src/lib.rs

@@ -25,23 +25,29 @@ pub use machine::Machine;
 
 use arbutil::{Bytes32, PreimageType};
 use eyre::{Report, Result};
+use lru::LruCache;
 use machine::{
     argument_data_to_inbox, get_empty_preimage_resolver, GlobalState, MachineStatus,
     PreimageResolver,
 };
 use static_assertions::const_assert_eq;
 use std::{
     ffi::CStr,
+    num::NonZeroUsize,
     os::raw::{c_char, c_int},
     path::Path,
     ptr, slice,
     sync::{
         atomic::{self, AtomicU8},
-        Arc,
+        Arc, Mutex,
     },
 };
 use utils::CBytes;
 
+lazy_static::lazy_static! {
+    static ref BLOBHASH_PREIMAGE_CACHE: Mutex<LruCache<Bytes32, CBytes>> = Mutex::new(LruCache::new(NonZeroUsize::new(12).unwrap()));
+}
+
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct CByteArray {
@@ -326,32 +332,50 @@ pub struct ResolvedPreimage {
     pub len: isize, // negative if not found
 }
 
+macro_rules! handle_preimage_resolution {
+    ($context:expr, $ty:expr, $hash:expr, $resolver:expr) => {{
+        let res = $resolver($context, $ty.into(), $hash.as_ptr());
+        if res.len < 0 {
+            return None;
+        }
+        let data = CBytes::from_raw_parts(res.ptr, res.len as usize);
+        // Check if preimage rehashes to the provided hash
+        match crate::utils::hash_preimage(&data, $ty) {
+            Ok(have_hash) if have_hash.as_slice() == *$hash => {}
+            Ok(got_hash) => panic!(
+                "Resolved incorrect data for hash {} (rehashed to {})",
+                $hash,
+                Bytes32(got_hash),
+            ),
+            Err(err) => panic!(
+                "Failed to hash preimage from resolver (expecting hash {}): {}",
+                $hash, err,
+            ),
+        }
+        Some(data)
+    }};
+}
+
 #[no_mangle]
+#[cfg(feature = "native")]
 pub unsafe extern "C" fn arbitrator_set_preimage_resolver(
     mach: *mut Machine,
     resolver: unsafe extern "C" fn(u64, u8, *const u8) -> ResolvedPreimage,
 ) {
     (*mach).set_preimage_resolver(Arc::new(
         move |context: u64, ty: PreimageType, hash: Bytes32| -> Option<CBytes> {
-            let res = resolver(context, ty.into(), hash.as_ptr());
-            if res.len < 0 {
+            if let PreimageType::EthVersionedHash = ty {
+                let mut cache = BLOBHASH_PREIMAGE_CACHE.lock().unwrap();
+                if cache.contains(&hash) {
+                    return cache.get(&hash).cloned();
+                }
+                if let Some(data) = handle_preimage_resolution!(context, ty, hash, resolver) {
+                    cache.put(hash, data.clone());
+                    return Some(data);
+                }
                 return None;
             }
-            let data = CBytes::from_raw_parts(res.ptr, res.len as usize);
-            #[cfg(debug_assertions)]
-            match crate::utils::hash_preimage(&data, ty) {
-                Ok(have_hash) if have_hash.as_slice() == *hash => {}
-                Ok(got_hash) => panic!(
-                    "Resolved incorrect data for hash {} (rehashed to {})",
-                    hash,
-                    Bytes32(got_hash),
-                ),
-                Err(err) => panic!(
-                    "Failed to hash preimage from resolver (expecting hash {}): {}",
-                    hash, err,
-                ),
-            }
-            Some(data)
+            handle_preimage_resolution!(context, ty, hash, resolver)
         },
     ) as PreimageResolver);
 }