Scroll evm executor/v35

Cargo.toml

@@ -22,3 +22,6 @@ debug = true
 [profile.ethtests]
 inherits = "test"
 opt-level = 3
+
+[patch."https://github.com/privacy-scaling-explorations/halo2.git"]
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }

crates/interpreter/Cargo.toml

@@ -40,6 +40,16 @@ negate-optimism-default-handler = [
     "revm-primitives/negate-optimism-default-handler",
 ]
 
+scroll = ["revm-primitives/scroll"]
+# Scroll default handler enabled Scroll handler register by default in EvmBuilder.
+scroll-default-handler = [
+    "scroll",
+    "revm-primitives/scroll-default-handler",
+]
+negate-scroll-default-handler = [
+    "revm-primitives/negate-scroll-default-handler",
+]
+
 dev = [
     "memory_limit",
     "optional_balance_check",

crates/interpreter/src/host.rs

@@ -31,6 +31,10 @@ pub trait Host {
     /// Get code hash of `address` and if the account is cold.
     fn code_hash(&mut self, address: Address) -> Option<(B256, bool)>;
 
+    #[cfg(feature = "scroll")]
+    /// Get keccak code hash of `address` and if the account is cold.
+    fn keccak_code_hash(&mut self, address: Address) -> Option<(B256, bool)>;
+
     /// Get storage value of `address` at `index` and if the account is cold.
     fn sload(&mut self, address: Address, index: U256) -> Option<(U256, bool)>;
 

crates/interpreter/src/host/dummy.rs

@@ -5,6 +5,9 @@ use crate::{
 };
 use std::vec::Vec;
 
+#[cfg(feature = "scroll")]
+use revm_primitives::POSEIDON_EMPTY;
+
 /// A dummy [Host] implementation.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct DummyHost {
@@ -64,10 +67,23 @@ impl Host for DummyHost {
     }
 
     #[inline]
+    #[cfg(not(feature = "scroll"))]
     fn code_hash(&mut self, __address: Address) -> Option<(B256, bool)> {
         Some((KECCAK_EMPTY, false))
     }
 
+    #[inline]
+    #[cfg(feature = "scroll")]
+    fn code_hash(&mut self, __address: Address) -> Option<(B256, bool)> {
+        Some((POSEIDON_EMPTY, false))
+    }
+
+    #[inline]
+    #[cfg(feature = "scroll")]
+    fn keccak_code_hash(&mut self, __address: Address) -> Option<(B256, bool)> {
+        Some((KECCAK_EMPTY, false))
+    }
+
     #[inline]
     fn sload(&mut self, __address: Address, index: U256) -> Option<(U256, bool)> {
         match self.storage.entry(index) {

crates/interpreter/src/instructions/host.rs

@@ -72,7 +72,13 @@ pub fn extcodesize<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mu
 pub fn extcodehash<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H) {
     check!(interpreter, CONSTANTINOPLE);
     pop_address!(interpreter, address);
-    let Some((code_hash, is_cold)) = host.code_hash(address) else {
+
+    #[cfg(not(feature = "scroll"))]
+    let result = host.code_hash(address);
+    #[cfg(feature = "scroll")]
+    let result = host.keccak_code_hash(address);
+
+    let Some((code_hash, is_cold)) = result else {
         interpreter.instruction_result = InstructionResult::FatalExternalError;
         return;
     };
@@ -120,14 +126,23 @@ pub fn extcodecopy<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mu
         .set_data(memory_offset, code_offset, len, code.bytes());
 }
 
-pub fn blockhash<H: Host>(interpreter: &mut Interpreter, host: &mut H) {
+pub fn blockhash<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H) {
     gas!(interpreter, gas::BLOCKHASH);
     pop_top!(interpreter, number);
 
     if let Some(diff) = host.env().block.number.checked_sub(*number) {
         let diff = as_usize_saturated!(diff);
         // blockhash should push zero if number is same as current block number.
         if diff <= BLOCK_HASH_HISTORY && diff != 0 {
+            #[cfg(feature = "scroll")]
+            if SPEC::enabled(BERNOULLI) {
+                let number64 = as_usize_or_fail!(interpreter, number);
+                let mut hasher = crate::primitives::Keccak256::new();
+                hasher.update(host.env().cfg.chain_id.to_be_bytes());
+                hasher.update(number64.to_be_bytes());
+                *number = U256::from_be_bytes(*hasher.finalize());
+                return;
+            }
             let Some(hash) = host.block_hash(*number) else {
                 interpreter.instruction_result = InstructionResult::FatalExternalError;
                 return;
@@ -231,6 +246,12 @@ pub fn selfdestruct<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &m
     check_staticcall!(interpreter);
     pop_address!(interpreter, target);
 
+    #[cfg(feature = "scroll")]
+    if SPEC::enabled(BERNOULLI) {
+        interpreter.instruction_result = InstructionResult::NotActivated;
+        return;
+    }
+
     let Some(res) = host.selfdestruct(interpreter.contract.address, target) else {
         interpreter.instruction_result = InstructionResult::FatalExternalError;
         return;

crates/interpreter/src/instructions/host_env.rs

@@ -47,6 +47,11 @@ pub fn gasprice<H: Host>(interpreter: &mut Interpreter, host: &mut H) {
 
 /// EIP-3198: BASEFEE opcode
 pub fn basefee<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H) {
+    #[cfg(feature = "scroll")]
+    if SPEC::enabled(BERNOULLI) {
+        interpreter.instruction_result = crate::InstructionResult::NotActivated;
+        return;
+    }
     check!(interpreter, LONDON);
     gas!(interpreter, gas::BASE);
     push!(interpreter, host.env().block.basefee);

crates/interpreter/src/instructions/opcode.rs

@@ -235,7 +235,7 @@ opcodes! {
     0x3D => RETURNDATASIZE => system::returndatasize::<H, SPEC>,
     0x3E => RETURNDATACOPY => system::returndatacopy::<H, SPEC>,
     0x3F => EXTCODEHASH    => host::extcodehash::<H, SPEC>,
-    0x40 => BLOCKHASH      => host::blockhash,
+    0x40 => BLOCKHASH      => host::blockhash::<H, SPEC>,
     0x41 => COINBASE       => host_env::coinbase,
     0x42 => TIMESTAMP      => host_env::timestamp,
     0x43 => NUMBER         => host_env::number,
@@ -947,6 +947,11 @@ pub const fn spec_opcode_gas(spec_id: SpecId) -> &'static [OpInfo; 256] {
                     const TABLE: &[OpInfo;256] = &make_gas_table(SpecId::ECOTONE);
                     TABLE
                 }
+                #[cfg(feature = "scroll")]
+                SpecId::BERNOULLI => {
+                    const TABLE: &[OpInfo;256] = &make_gas_table(SpecId::BERNOULLI);
+                    TABLE
+                }
             }
         };
     }

crates/interpreter/src/interpreter/analysis.rs

@@ -6,6 +6,9 @@ use crate::primitives::{
 use core::fmt;
 use std::sync::Arc;
 
+#[cfg(feature = "scroll")]
+use crate::primitives::{poseidon, POSEIDON_EMPTY};
+
 /// Perform bytecode analysis.
 ///
 /// The analysis finds and caches valid jump destinations for later execution as an optimization step.
@@ -124,8 +127,9 @@ impl BytecodeLocked {
         self.original_len == 0
     }
 
-    /// Calculate hash of the bytecode.
+    /// Calculate poseidon hash of the bytecode.
     #[inline]
+    #[cfg(not(feature = "scroll"))]
     pub fn hash_slow(&self) -> B256 {
         if self.is_empty() {
             KECCAK_EMPTY
@@ -134,6 +138,28 @@ impl BytecodeLocked {
         }
     }
 
+    /// Calculate poseidon hash of the bytecode.
+    #[inline]
+    #[cfg(feature = "scroll")]
+    pub fn poseidon_hash_slow(&self) -> B256 {
+        if self.is_empty() {
+            POSEIDON_EMPTY
+        } else {
+            poseidon(self.original_bytecode_slice())
+        }
+    }
+
+    /// Calculate keccak hash of the bytecode.
+    #[inline]
+    #[cfg(feature = "scroll")]
+    pub fn keccak_hash_slow(&self) -> B256 {
+        if self.is_empty() {
+            KECCAK_EMPTY
+        } else {
+            keccak256(self.original_bytecode_slice())
+        }
+    }
+
     #[inline]
     pub fn unlock(self) -> Bytecode {
         Bytecode {

crates/precompile/Cargo.toml

@@ -60,6 +60,16 @@ negate-optimism-default-handler = [
     "revm-primitives/negate-optimism-default-handler",
 ]
 
+scroll = ["revm-primitives/scroll"]
+# Scroll default handler enabled Scroll handler register by default in EvmBuilder.
+scroll-default-handler = [
+    "scroll",
+    "revm-primitives/scroll-default-handler",
+]
+negate-scroll-default-handler = [
+    "revm-primitives/negate-scroll-default-handler",
+]
+
 # These libraries may not work on all no_std platforms as they depend on C.
 
 # Enables the KZG point evaluation precompile.

crates/precompile/src/blake2.rs

@@ -1,12 +1,21 @@
 use crate::{Error, Precompile, PrecompileResult, PrecompileWithAddress};
 use revm_primitives::Bytes;
 
+#[cfg(feature = "scroll")]
+use revm_primitives::PrecompileError;
+
 const F_ROUND: u64 = 1;
 const INPUT_LENGTH: usize = 213;
 
 pub const FUN: PrecompileWithAddress =
     PrecompileWithAddress(crate::u64_to_address(9), Precompile::Standard(run));
 
+#[cfg(feature = "scroll")]
+pub const BERNOULLI: PrecompileWithAddress = PrecompileWithAddress(
+    crate::u64_to_address(9),
+    Precompile::Standard(|_input: &Bytes, _gas_limit: u64| Err(PrecompileError::NotImplemented)),
+);
+
 /// reference: <https://eips.ethereum.org/EIPS/eip-152>
 /// input format:
 /// [4 bytes for rounds][64 bytes for h][128 bytes for m][8 bytes for t_0][8 bytes for t_1][1 byte for f]

crates/precompile/src/hash.rs

@@ -3,6 +3,9 @@ use crate::{Error, Precompile, PrecompileResult, PrecompileWithAddress};
 use revm_primitives::Bytes;
 use sha2::Digest;
 
+#[cfg(feature = "scroll")]
+use revm_primitives::PrecompileError;
+
 pub const SHA256: PrecompileWithAddress =
     PrecompileWithAddress(crate::u64_to_address(2), Precompile::Standard(sha256_run));
 
@@ -11,6 +14,12 @@ pub const RIPEMD160: PrecompileWithAddress = PrecompileWithAddress(
     Precompile::Standard(ripemd160_run),
 );
 
+#[cfg(feature = "scroll")]
+pub const RIPEMD160_BERNOULLI: PrecompileWithAddress = PrecompileWithAddress(
+    crate::u64_to_address(3),
+    Precompile::Standard(|_input: &Bytes, _gas_limit: u64| Err(PrecompileError::NotImplemented)),
+);
+
 /// See: <https://ethereum.github.io/yellowpaper/paper.pdf>
 /// See: <https://docs.soliditylang.org/en/develop/units-and-global-variables.html#mathematical-and-cryptographic-functions>
 /// See: <https://etherscan.io/address/0000000000000000000000000000000000000002>

crates/precompile/src/lib.rs

@@ -64,6 +64,8 @@ impl Precompiles {
             PrecompileSpecId::BYZANTIUM => Self::byzantium(),
             PrecompileSpecId::ISTANBUL => Self::istanbul(),
             PrecompileSpecId::BERLIN => Self::berlin(),
+            #[cfg(feature = "scroll")]
+            PrecompileSpecId::BERNOULLI => Self::bernoulli(),
             PrecompileSpecId::CANCUN => Self::cancun(),
             PrecompileSpecId::LATEST => Self::latest(),
         }
@@ -156,6 +158,27 @@ impl Precompiles {
         })
     }
 
+    /// Returns precompiles for Scroll
+    #[cfg(feature = "scroll")]
+    pub fn bernoulli() -> &'static Self {
+        static INSTANCE: OnceBox<Precompiles> = OnceBox::new();
+        INSTANCE.get_or_init(|| {
+            let mut precompiles = Precompiles::default();
+            precompiles.extend([
+                secp256k1::ECRECOVER,      // 0x01
+                hash::SHA256,              // 0x02
+                hash::RIPEMD160_BERNOULLI, // 0x03
+                identity::FUN,             // 0x04
+                modexp::BERNOULLI,         // 0x05
+                bn128::add::ISTANBUL,      // 0x06
+                bn128::mul::ISTANBUL,      // 0x07
+                bn128::pair::ISTANBUL,     // 0x08
+                blake2::BERNOULLI,         // 0x09
+            ]);
+            Box::new(precompiles)
+        })
+    }
+
     /// Returns the precompiles for the latest spec.
     pub fn latest() -> &'static Self {
         Self::cancun()
@@ -230,6 +253,8 @@ pub enum PrecompileSpecId {
     BYZANTIUM,
     ISTANBUL,
     BERLIN,
+    #[cfg(feature = "scroll")]
+    BERNOULLI,
     CANCUN,
     LATEST,
 }
@@ -251,6 +276,8 @@ impl PrecompileSpecId {
             BEDROCK | REGOLITH | CANYON => Self::BERLIN,
             #[cfg(feature = "optimism")]
             ECOTONE => Self::CANCUN,
+            #[cfg(feature = "scroll")]
+            BERNOULLI => Self::BERNOULLI,
         }
     }
 }

crates/precompile/src/modexp.rs

@@ -7,6 +7,9 @@ use aurora_engine_modexp::modexp;
 use core::cmp::{max, min};
 use revm_primitives::Bytes;
 
+#[cfg(feature = "scroll")]
+const SCROLL_LEN_LIMIT: U256 = U256::from_limbs([32, 0, 0, 0]);
+
 pub const BYZANTIUM: PrecompileWithAddress = PrecompileWithAddress(
     crate::u64_to_address(5),
     Precompile::Standard(byzantium_run),
@@ -15,6 +18,12 @@ pub const BYZANTIUM: PrecompileWithAddress = PrecompileWithAddress(
 pub const BERLIN: PrecompileWithAddress =
     PrecompileWithAddress(crate::u64_to_address(5), Precompile::Standard(berlin_run));
 
+#[cfg(feature = "scroll")]
+pub const BERNOULLI: PrecompileWithAddress = PrecompileWithAddress(
+    crate::u64_to_address(5),
+    Precompile::Standard(bernoilli_run),
+);
+
 /// See: <https://eips.ethereum.org/EIPS/eip-198>
 /// See: <https://etherscan.io/address/0000000000000000000000000000000000000005>
 pub fn byzantium_run(input: &Bytes, gas_limit: u64) -> PrecompileResult {
@@ -29,6 +38,28 @@ pub fn berlin_run(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     })
 }
 
+#[cfg(feature = "scroll")]
+pub fn bernoilli_run(input: &Bytes, gas_limit: u64) -> PrecompileResult {
+    let base_len = U256::from_be_bytes(right_pad_with_offset::<32>(input, 0).into_owned());
+    let exp_len = U256::from_be_bytes(right_pad_with_offset::<32>(input, 32).into_owned());
+    let mod_len = U256::from_be_bytes(right_pad_with_offset::<32>(input, 64).into_owned());
+
+    // modexp temporarily only accepts inputs of 32 bytes (256 bits) or less
+    if base_len > SCROLL_LEN_LIMIT {
+        return Err(Error::ModexpBaseOverflow);
+    }
+    if exp_len > SCROLL_LEN_LIMIT {
+        return Err(Error::ModexpExpOverflow);
+    }
+    if mod_len > SCROLL_LEN_LIMIT {
+        return Err(Error::ModexpModOverflow);
+    }
+
+    run_inner(input, gas_limit, 200, |a, b, c, d| {
+        berlin_gas_calc(a, b, c, d)
+    })
+}
+
 pub fn calculate_iteration_count(exp_length: u64, exp_highp: &U256) -> u64 {
     let mut iteration_count: u64 = 0;
 

crates/primitives/Cargo.toml

@@ -41,6 +41,10 @@ serde = { version = "1.0", default-features = false, features = [
     "rc",
 ], optional = true }
 
+# scroll
+halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1", optional = true }
+hash-circuit = { package = "poseidon-circuit", git = "https://github.com/scroll-tech/poseidon-circuit.git", branch = "scroll-dev-1201", optional = true }
+
 [build-dependencies]
 hex = { version = "0.4", default-features = false }
 
@@ -71,6 +75,11 @@ optimism = []
 optimism-default-handler = ["optimism"]
 negate-optimism-default-handler = []
 
+scroll = ["halo2_proofs", "hash-circuit"]
+# Scroll default handler enabled Scroll handler register by default in EvmBuilder.
+scroll-default-handler = ["scroll"]
+negate-scroll-default-handler = []
+
 dev = [
     "memory_limit",
     "optional_balance_check",