runtime: start lifting contract preparation up through tx runtime layers

runtime/near-vm-runner/fuzz/fuzz_targets/diffrunner.rs

@@ -21,19 +21,19 @@ libfuzzer_sys::fuzz_target!(|module: ArbitraryModule| {
 fn run_fuzz(code: &ContractCode, vm_kind: VMKind) -> VMOutcome {
     let mut fake_external = MockedExternal::with_code(code.clone_for_tests());
     let method_name = find_entry_point(code).unwrap_or_else(|| "main".to_string());
-    let mut context = create_context(&method_name, vec![]);
+    let mut context = create_context(vec![]);
     context.prepaid_gas = 10u64.pow(14);
     let config_store = RuntimeConfigStore::new(None);
     let config = config_store.get_config(PROTOCOL_VERSION);
     let fees = Arc::clone(&config.fees);
     let mut wasm_config = near_parameters::vm::Config::clone(&config.wasm_config);
     wasm_config.limit_config.contract_prepare_version =
         near_vm_runner::logic::ContractPrepareVersion::V2;
-
+    let gas_counter = context.make_gas_counter(&wasm_config);
     let res = vm_kind
         .runtime(wasm_config.into())
         .unwrap()
-        .prepare(&fake_external, &context, None)
+        .prepare(&fake_external, None, gas_counter, &method_name)
         .run(&mut fake_external, &context, fees);
 
     // Remove the VMError message details as they can differ between runtimes

runtime/near-vm-runner/fuzz/fuzz_targets/runner.rs

@@ -19,16 +19,17 @@ libfuzzer_sys::fuzz_target!(|module: ArbitraryModule| {
 fn run_fuzz(code: &ContractCode, config: Arc<RuntimeConfig>) -> VMOutcome {
     let mut fake_external = MockedExternal::with_code(code.clone_for_tests());
     let method_name = find_entry_point(code).unwrap_or_else(|| "main".to_string());
-    let mut context = create_context(&method_name, vec![]);
+    let mut context = create_context(vec![]);
     context.prepaid_gas = 10u64.pow(14);
     let mut wasm_config = near_parameters::vm::Config::clone(&config.wasm_config);
     wasm_config.limit_config.wasmer2_stack_limit = i32::MAX; // If we can crash wasmer2 even without the secondary stack limit it's still good to know
     let vm_kind = config.wasm_config.vm_kind;
     let fees = Arc::clone(&config.fees);
+    let gas_counter = context.make_gas_counter(&wasm_config);
     vm_kind
         .runtime(wasm_config.into())
         .unwrap()
-        .prepare(&fake_external, &context, None)
+        .prepare(&fake_external, None, gas_counter, &method_name)
         .run(&mut fake_external, &context, fees)
         .unwrap_or_else(|err| panic!("fatal error: {err:?}"))
 }

runtime/near-vm-runner/fuzz/src/lib.rs

@@ -30,13 +30,12 @@ pub fn find_entry_point(contract: &ContractCode) -> Option<String> {
     None
 }
 
-pub fn create_context(method: &str, input: Vec<u8>) -> VMContext {
+pub fn create_context(input: Vec<u8>) -> VMContext {
     VMContext {
         current_account_id: "alice".parse().unwrap(),
         signer_account_id: "bob".parse().unwrap(),
         signer_account_pk: vec![0, 1, 2, 3, 4],
         predecessor_account_id: "carol".parse().unwrap(),
-        method: method.into(),
         input,
         promise_results: Vec::new().into(),
         block_height: 10,

runtime/near-vm-runner/src/lib.rs

@@ -36,7 +36,7 @@ pub use code::ContractCode;
 #[cfg(feature = "metrics")]
 pub use metrics::{report_metrics, reset_metrics};
 pub use profile::ProfileDataV3;
-pub use runner::{run, PreparedContract, VM};
+pub use runner::{prepare, run, Contract, PreparedContract, VM};
 
 /// This is public for internal experimentation use only, and should otherwise be considered an
 /// implementation detail of `near-vm-runner`.

runtime/near-vm-runner/src/logic/context.rs

@@ -20,8 +20,6 @@ pub struct VMContext {
     /// If this execution is the result of direct execution of transaction then it
     /// is equal to `signer_account_id`.
     pub predecessor_account_id: AccountId,
-    /// The name of the method to invoke.
-    pub method: String,
     /// The input to the contract call.
     /// Encoded as base64 string to be able to pass input in borsh binary format.
     pub input: Vec<u8>,
@@ -62,4 +60,21 @@ impl VMContext {
     pub fn is_view(&self) -> bool {
         self.view_config.is_some()
     }
+
+    /// Make a gas counter based on the configuration in this VMContext.
+    ///
+    /// Meant for use in tests only.
+    pub fn make_gas_counter(&self, config: &near_parameters::vm::Config) -> super::GasCounter {
+        let max_gas_burnt = match self.view_config {
+            Some(near_primitives_core::config::ViewConfig { max_gas_burnt }) => max_gas_burnt,
+            None => config.limit_config.max_gas_burnt,
+        };
+        crate::logic::GasCounter::new(
+            config.ext_costs.clone(),
+            max_gas_burnt,
+            config.regular_op_cost,
+            self.prepaid_gas,
+            self.is_view(),
+        )
+    }
 }

runtime/near-vm-runner/src/logic/dependencies.rs

@@ -488,10 +488,4 @@ pub trait External {
     ///
     /// Panics if `ReceiptIndex` is invalid.
     fn get_receipt_receiver(&self, receipt_index: ReceiptIndex) -> &AccountId;
-
-    /// Hash of the contract for the current account.
-    fn code_hash(&self) -> CryptoHash;
-
-    /// Get the contract code
-    fn get_contract(&self) -> Option<std::sync::Arc<crate::ContractCode>>;
 }

runtime/near-vm-runner/src/logic/gas_counter.rs

@@ -26,7 +26,7 @@ type Result<T> = ::std::result::Result<T, VMLogicError>;
 /// instance by intrinsifying host functions responsible for gas metering.
 #[repr(C)]
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FastGasCounter {
+pub(crate) struct FastGasCounter {
     /// The following three fields must be put next to another to make sure
     /// generated gas counting code can use and adjust them.
     /// We will share counter to ensure we never miss synchronization.
@@ -119,7 +119,7 @@ impl GasCounter {
     /// Simpler version of `deduct_gas()` for when no promises are involved.
     ///
     /// Return an error if there are arithmetic overflows.
-    pub fn burn_gas(&mut self, gas_burnt: Gas) -> Result<()> {
+    pub(crate) fn burn_gas(&mut self, gas_burnt: Gas) -> Result<()> {
         let new_burnt_gas =
             self.fast_counter.burnt_gas.checked_add(gas_burnt).ok_or(HostError::IntegerOverflow)?;
         if new_burnt_gas <= self.fast_counter.gas_limit {
@@ -138,7 +138,7 @@ impl GasCounter {
         }
     }
 
-    pub fn process_gas_limit(&mut self, new_burnt_gas: Gas, new_used_gas: Gas) -> HostError {
+    pub(crate) fn process_gas_limit(&mut self, new_burnt_gas: Gas, new_used_gas: Gas) -> HostError {
         use std::cmp::min;
         // Never burn more gas than what was paid for.
         let hard_burnt_limit = min(self.prepaid_gas, self.max_gas_burnt);
@@ -178,22 +178,90 @@ impl GasCounter {
     }
 
     /// Very special function to get the gas counter pointer for generated machine code.
+    ///
     /// Please do not use, unless fully understand Rust aliasing and other consequences.
-    /// Can be used to emit inlined code like `pay_wasm_gas()`, i.e.
-    ///    mov base, gas_counter_raw_ptr
-    ///    mov rax, [base + 0] ; current burnt gas
-    ///    mov rcx, [base + 16] ; opcode cost
-    ///    imul rcx, block_ops_count ; block cost
-    ///    add rax, rcx ; new burnt gas
-    ///    jo emit_integer_overflow
-    ///    cmp rax, [base + 8] ; unsigned compare with burnt limit
-    ///    mov [base + 0], rax
-    ///    ja emit_gas_exceeded
-    pub fn gas_counter_raw_ptr(&mut self) -> *mut FastGasCounter {
+    #[cfg(all(any(feature = "wasmer2_vm", feature = "near_vm"), target_arch = "x86_64"))]
+    pub(crate) fn fast_counter_raw_ptr(&mut self) -> *mut FastGasCounter {
         use std::ptr;
         ptr::addr_of_mut!(self.fast_counter)
     }
 
+    /// Add a cost for loading the contract code in the VM.
+    ///
+    /// This cost does not consider the structure of the contract code, only the
+    /// size. This is currently the only loading fee. A fee that takes the code
+    /// structure into consideration could be added. But since that would have
+    /// to happen after loading, we cannot pre-charge it. This is the main
+    /// motivation to (only) have this simple fee.
+    #[cfg(any(
+        feature = "wasmtime_vm",
+        all(
+            target_arch = "x86_64",
+            any(feature = "wasmer0_vm", feature = "wasmer2_vm", feature = "near_vm")
+        )
+    ))]
+    pub(crate) fn add_contract_loading_fee(&mut self, code_len: u64) -> Result<()> {
+        self.pay_per(ExtCosts::contract_loading_bytes, code_len)?;
+        self.pay_base(ExtCosts::contract_loading_base)
+    }
+
+    /// VM independent setup before loading the executable.
+    ///
+    /// Does VM independent checks that happen after the instantiation of
+    /// VMLogic but before loading the executable. This includes pre-charging gas
+    /// costs for loading the executable, which depends on the size of the WASM code.
+    #[cfg(any(
+        feature = "wasmtime_vm",
+        all(
+            target_arch = "x86_64",
+            any(feature = "wasmer0_vm", feature = "wasmer2_vm", feature = "near_vm")
+        )
+    ))]
+    pub(crate) fn before_loading_executable(
+        &mut self,
+        config: &near_parameters::vm::Config,
+        method_name: &str,
+        wasm_code_bytes: u64,
+    ) -> std::result::Result<(), super::errors::FunctionCallError> {
+        if method_name.is_empty() {
+            let error = super::errors::FunctionCallError::MethodResolveError(
+                super::errors::MethodResolveError::MethodEmptyName,
+            );
+            return Err(error);
+        }
+        if config.fix_contract_loading_cost {
+            if self.add_contract_loading_fee(wasm_code_bytes).is_err() {
+                let error =
+                    super::errors::FunctionCallError::HostError(super::HostError::GasExceeded);
+                return Err(error);
+            }
+        }
+        Ok(())
+    }
+
+    /// Legacy code to preserve old gas charging behaviour in old protocol versions.
+    #[cfg(any(
+        feature = "wasmtime_vm",
+        all(
+            target_arch = "x86_64",
+            any(feature = "wasmer0_vm", feature = "wasmer2_vm", feature = "near_vm")
+        )
+    ))]
+    pub(crate) fn after_loading_executable(
+        &mut self,
+        config: &near_parameters::vm::Config,
+        wasm_code_bytes: u64,
+    ) -> std::result::Result<(), super::errors::FunctionCallError> {
+        if !config.fix_contract_loading_cost {
+            if self.add_contract_loading_fee(wasm_code_bytes).is_err() {
+                return Err(super::errors::FunctionCallError::HostError(
+                    super::HostError::GasExceeded,
+                ));
+            }
+        }
+        Ok(())
+    }
+
     #[inline]
     fn inc_ext_costs_counter(&mut self, cost: ExtCosts, value: u64) {
         with_ext_cost_counter(|cc| *cc.entry(cost).or_default() += value)
@@ -210,7 +278,7 @@ impl GasCounter {
     }
 
     /// A helper function to pay a multiple of a cost.
-    pub fn pay_per(&mut self, cost: ExtCosts, num: u64) -> Result<()> {
+    pub(crate) fn pay_per(&mut self, cost: ExtCosts, num: u64) -> Result<()> {
         let use_gas =
             num.checked_mul(cost.gas(&self.ext_costs_config)).ok_or(HostError::IntegerOverflow)?;
 
@@ -222,7 +290,7 @@ impl GasCounter {
     }
 
     /// A helper function to pay base cost gas.
-    pub fn pay_base(&mut self, cost: ExtCosts) -> Result<()> {
+    pub(crate) fn pay_base(&mut self, cost: ExtCosts) -> Result<()> {
         let base_fee = cost.gas(&self.ext_costs_config);
         self.inc_ext_costs_counter(cost, 1);
         let old_burnt_gas = self.fast_counter.burnt_gas;
@@ -236,7 +304,7 @@ impl GasCounter {
     /// * `burn_gas`: amount of gas to burn;
     /// * `use_gas`: amount of gas to reserve;
     /// * `action`: what kind of action is charged for;
-    pub fn pay_action_accumulated(
+    pub(crate) fn pay_action_accumulated(
         &mut self,
         burn_gas: Gas,
         use_gas: Gas,
@@ -251,31 +319,26 @@ impl GasCounter {
         deduct_gas_result
     }
 
-    pub fn add_trie_fees(&mut self, count: &TrieNodesCount) -> Result<()> {
+    pub(crate) fn add_trie_fees(&mut self, count: &TrieNodesCount) -> Result<()> {
         self.pay_per(touching_trie_node, count.db_reads)?;
         self.pay_per(read_cached_trie_node, count.mem_reads)?;
         Ok(())
     }
 
-    pub fn prepay_gas(&mut self, use_gas: Gas) -> Result<()> {
+    pub(crate) fn prepay_gas(&mut self, use_gas: Gas) -> Result<()> {
         self.deduct_gas(0, use_gas)
     }
 
-    pub fn burnt_gas(&self) -> Gas {
+    pub(crate) fn burnt_gas(&self) -> Gas {
         self.fast_counter.burnt_gas
     }
 
     /// Amount of gas used through promises and amount burned.
-    pub fn used_gas(&self) -> Gas {
+    pub(crate) fn used_gas(&self) -> Gas {
         self.promises_gas + self.fast_counter.burnt_gas
     }
 
-    /// Remaining gas based on the amount of prepaid gas not yet used.
-    pub fn unused_gas(&self) -> Gas {
-        self.prepaid_gas - self.used_gas()
-    }
-
-    pub fn profile_data(&self) -> ProfileDataV3 {
+    pub(crate) fn profile_data(&self) -> ProfileDataV3 {
         self.profile.clone()
     }
 }