Merge pull request #191 from OffchainLabs/code

account_code and account_code_size host I/Os

Author: rachel-bousfield

arbitrator/arbutil/src/evm/api.rs

@@ -42,6 +42,8 @@ pub enum EvmApiMethod {
     GetReturnData,
     EmitLog,
     AccountBalance,
+    AccountCode,
+    AccountCodeSize,
     AccountCodeHash,
     AddPages,
 }
@@ -125,9 +127,23 @@ pub trait EvmApi: Send + 'static {
     /// Analogous to `vm.BALANCE`.
     fn account_balance(&mut self, address: Bytes20) -> (Bytes32, u64);
 
+    /// Returns the code and the access cost in gas.
+    /// Analogous to `vm.EXTCODECOPY`.
+    fn account_code(
+        &mut self,
+        address: Bytes20,
+        offset: u32,
+        size: u32,
+        gas_left: u64,
+    ) -> (Vec<u8>, u64);
+
+    /// Returns the code size and the access cost in gas.
+    /// Analogous to `vm.EXTCODESIZE`.
+    fn account_code_size(&mut self, address: Bytes20, gas_left: u64) -> (u32, u64);
+
     /// Gets the hash of the given address's code.
     /// Returns the hash and the access cost in gas.
-    /// Analogous to `vm.CODEHASH`.
+    /// Analogous to `vm.EXTCODEHASH`.
     fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, u64);
 
     /// Determines the cost in gas of allocating additional wasm pages.

arbitrator/arbutil/src/evm/js.rs

@@ -296,6 +296,22 @@ impl<T: JsCallIntoGo> EvmApi for JsEvmApi<T> {
         (value.assert_bytes32(), cost.assert_u64())
     }
 
+    fn account_code(
+        &mut self,
+        address: Bytes20,
+        offset: u32,
+        size: u32,
+        gas_left: u64,
+    ) -> (Vec<u8>, u64) {
+        let [value, cost] = call!(self, 2, AccountCode, address, offset, size, gas_left);
+        (value.assert_bytes(), cost.assert_u64())
+    }
+
+    fn account_code_size(&mut self, address: Bytes20, gas_left: u64) -> (u32, u64) {
+        let [value, cost] = call!(self, 2, AccountCodeSize, address, gas_left);
+        (value.assert_u32(), cost.assert_u64())
+    }
+
     fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, u64) {
         let [value, cost] = call!(self, 2, AccountCodeHash, address);
         (value.assert_bytes32(), cost.assert_u64())

arbitrator/arbutil/src/evm/mod.rs

@@ -10,6 +10,12 @@ pub mod user;
 // params.SstoreSentryGasEIP2200
 pub const SSTORE_SENTRY_GAS: u64 = 2300;
 
+// params.ColdAccountAccessCostEIP2929
+pub const COLD_ACCOUNT_GAS: u64 = 2600;
+
+// params.ColdSloadCostEIP2929
+pub const COLD_SLOAD_GAS: u64 = 2100;
+
 // params.LogGas and params.LogDataGas
 pub const LOG_TOPIC_GAS: u64 = 375;
 pub const LOG_DATA_GAS: u64 = 8;

arbitrator/langs/bf

@@ -575,7 +575,7 @@ impl<'a> WasmBinary<'a> {
         let asm_estimate = 5 * 1024 * 1024;
 
         // TODO: determine safe value
-        let init_gas = 2048;
+        let init_gas = 4096;
 
         let [ink_left, ink_status] = meter.globals();
         let depth_left = depth.globals();

arbitrator/langs/c

@@ -64,6 +64,16 @@ pub struct GoEvmApi {
         unsafe extern "C" fn(id: usize, data: *mut RustBytes, topics: u32) -> EvmApiStatus,
     pub account_balance:
         unsafe extern "C" fn(id: usize, address: Bytes20, gas_cost: *mut u64) -> Bytes32, // balance
+    pub account_code: unsafe extern "C" fn(
+        id: usize,
+        code: *mut RustBytes,
+        address: Bytes20,
+        offset: u32,
+        size: u32,
+        gas_cost: *mut u64,
+    ),
+    pub account_code_size:
+        unsafe extern "C" fn(id: usize, address: Bytes20, gas_cost: *mut u64) -> u32, // code size
     pub account_codehash:
         unsafe extern "C" fn(id: usize, address: Bytes20, gas_cost: *mut u64) -> Bytes32, // codehash
     pub add_pages: unsafe extern "C" fn(id: usize, pages: u16) -> u64, // gas cost
@@ -250,6 +260,33 @@ impl EvmApi for GoEvmApi {
         (value, cost)
     }
 
+    fn account_code(
+        &mut self,
+        address: Bytes20,
+        offset: u32,
+        size: u32,
+        gas_left: u64,
+    ) -> (Vec<u8>, u64) {
+        let mut data = RustBytes::new(vec![]);
+        let mut cost = gas_left; // pass amount left
+        call!(
+            self,
+            account_code,
+            ptr!(data),
+            address,
+            offset,
+            size,
+            ptr!(cost)
+        );
+        (into_vec!(data), cost)
+    }
+
+    fn account_code_size(&mut self, address: Bytes20, gas_left: u64) -> (u32, u64) {
+        let mut cost = gas_left; // pass amount left
+        let size = call!(self, account_code_size, address, ptr!(cost));
+        (size, cost)
+    }
+
     fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, u64) {
         let mut cost = 0;
         let value = call!(self, account_codehash, address, ptr!(cost));

arbitrator/langs/rust

@@ -219,6 +219,23 @@ pub(crate) fn account_balance<E: EvmApi>(
     hostio!(env, account_balance(address, ptr))
 }
 
+pub(crate) fn account_code<E: EvmApi>(
+    mut env: WasmEnvMut<E>,
+    address: u32,
+    offset: u32,
+    size: u32,
+    code: u32,
+) -> Result<u32, Escape> {
+    hostio!(env, account_code(address, offset, size, code))
+}
+
+pub(crate) fn account_code_size<E: EvmApi>(
+    mut env: WasmEnvMut<E>,
+    address: u32,
+) -> Result<u32, Escape> {
+    hostio!(env, account_code_size(address))
+}
+
 pub(crate) fn account_codehash<E: EvmApi>(
     mut env: WasmEnvMut<E>,
     address: u32,

arbitrator/prover/src/binary.rs

@@ -136,7 +136,9 @@ impl<E: EvmApi> NativeInstance<E> {
                 "return_data_size" => func!(host::return_data_size),
                 "emit_log" => func!(host::emit_log),
                 "account_balance" => func!(host::account_balance),
+                "account_code" => func!(host::account_code),
                 "account_codehash" => func!(host::account_codehash),
+                "account_code_size" => func!(host::account_code_size),
                 "evm_gas_left" => func!(host::evm_gas_left),
                 "evm_ink_left" => func!(host::evm_ink_left),
                 "block_basefee" => func!(host::block_basefee),
@@ -342,7 +344,9 @@ pub fn module(wasm: &[u8], compile: CompileConfig) -> Result<Vec<u8>> {
             "return_data_size" => stub!(u32 <- ||),
             "emit_log" => stub!(|_: u32, _: u32, _: u32|),
             "account_balance" => stub!(|_: u32, _: u32|),
+            "account_code" => stub!(u32 <- |_: u32, _: u32, _: u32, _: u32|),
             "account_codehash" => stub!(|_: u32, _: u32|),
+            "account_code_size" => stub!(u32 <- |_: u32|),
             "evm_gas_left" => stub!(u64 <- ||),
             "evm_ink_left" => stub!(u64 <- ||),
             "block_basefee" => stub!(|_: u32|),