Standardize Wasm fuel metering (#3647)

## Motivation

Wasmer and Wasmtime had different fuel metering implementations. When
using Wasmer, the code used bytecode instrumentation, altering the Wasm
bytecode to call back to the host to consume fuel. When using Wasmtime,
the code used Wasmtime's own native fuel metering implementation. This
led to inconsistencies and required a sanitizer to try to ensure both
runtimes measured fuel consumption the same way.

## Proposal

Use the same bytecode instrumentation for all runtimes. This allows
removing the sanitizer.

## Test Plan

CI should catch any regressions.

## Release Plan

- These changes follow the usual release cycle, because this only
contains an internal refactor that should not affect any visible
behavior.

## Links

- Closes #1967 
- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

Author: jvff

Cargo.lock

@@ -23,20 +23,8 @@ revm = [
 ]
 fs = ["tokio/fs"]
 metrics = ["prometheus", "linera-views/metrics"]
-wasmer = [
-    "dep:wasmer",
-    "wasmer/enable-serde",
-    "linera-witty/wasmer",
-    "wasm-encoder",
-    "wasm-instrument",
-    "wasmparser",
-]
-wasmtime = [
-    "dep:wasmtime",
-    "linera-witty/wasmtime",
-    "wasm-encoder",
-    "wasmparser",
-]
+wasmer = ["dep:wasmer", "wasmer/enable-serde", "linera-witty/wasmer"]
+wasmtime = ["dep:wasmtime", "linera-witty/wasmtime"]
 web = ["linera-base/web", "linera-views/web", "js-sys"]
 
 [dependencies]
@@ -75,9 +63,7 @@ tempfile = { workspace = true, optional = true }
 thiserror.workspace = true
 tracing = { workspace = true, features = ["log"] }
 url.workspace = true
-wasm-encoder = { workspace = true, optional = true }
-wasm-instrument = { workspace = true, optional = true, features = ["sign_ext"] }
-wasmparser = { workspace = true, optional = true }
+wasm-instrument = { workspace = true, features = ["sign_ext"] }
 wasmtime = { workspace = true, optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

examples/Cargo.lock

@@ -1298,10 +1298,6 @@ pub enum WasmRuntime {
     #[cfg_attr(not(with_wasmer), default)]
     #[display("wasmtime")]
     Wasmtime,
-    #[cfg(with_wasmer)]
-    WasmerWithSanitizer,
-    #[cfg(with_wasmtime)]
-    WasmtimeWithSanitizer,
 }
 
 #[derive(Clone, Copy, Display)]
@@ -1318,19 +1314,6 @@ pub trait WithWasmDefault {
     fn with_wasm_default(self) -> Self;
 }
 
-impl WasmRuntime {
-    pub fn needs_sanitizer(self) -> bool {
-        match self {
-            #[cfg(with_wasmer)]
-            WasmRuntime::WasmerWithSanitizer => true,
-            #[cfg(with_wasmtime)]
-            WasmRuntime::WasmtimeWithSanitizer => true,
-            #[cfg(with_wasm_runtime)]
-            _ => false,
-        }
-    }
-}
-
 impl WithWasmDefault for Option<WasmRuntime> {
     fn with_wasm_default(self) -> Self {
         #[cfg(with_wasm_runtime)]

linera-execution/Cargo.toml

@@ -12,7 +12,6 @@
 
 mod entrypoints;
 mod module_cache;
-mod sanitizer;
 #[macro_use]
 mod runtime_api;
 #[cfg(with_wasmer)]
@@ -22,6 +21,7 @@ mod wasmtime;
 
 use linera_base::data_types::Bytecode;
 use thiserror::Error;
+use wasm_instrument::{gas_metering, parity_wasm};
 #[cfg(with_wasmer)]
 use wasmer::{WasmerContractInstance, WasmerServiceInstance};
 #[cfg(with_wasmtime)]
@@ -35,7 +35,6 @@ use {
     std::sync::LazyLock,
 };
 
-use self::sanitizer::sanitize;
 pub use self::{
     entrypoints::{ContractEntrypoints, ServiceEntrypoints},
     runtime_api::{BaseRuntimeApi, ContractRuntimeApi, RuntimeApiData, ServiceRuntimeApi},
@@ -83,22 +82,12 @@ impl WasmContractModule {
         contract_bytecode: Bytecode,
         runtime: WasmRuntime,
     ) -> Result<Self, WasmExecutionError> {
-        let contract_bytecode = if runtime.needs_sanitizer() {
-            // Ensure bytecode normalization whenever wasmer and wasmtime are possibly
-            // compared.
-            sanitize(contract_bytecode).map_err(WasmExecutionError::LoadContractModule)?
-        } else {
-            contract_bytecode
-        };
+        let contract_bytecode = add_metering(contract_bytecode)?;
         match runtime {
             #[cfg(with_wasmer)]
-            WasmRuntime::Wasmer | WasmRuntime::WasmerWithSanitizer => {
-                Self::from_wasmer(contract_bytecode).await
-            }
+            WasmRuntime::Wasmer => Self::from_wasmer(contract_bytecode).await,
             #[cfg(with_wasmtime)]
-            WasmRuntime::Wasmtime | WasmRuntime::WasmtimeWithSanitizer => {
-                Self::from_wasmtime(contract_bytecode).await
-            }
+            WasmRuntime::Wasmtime => Self::from_wasmtime(contract_bytecode).await,
         }
     }
 
@@ -159,13 +148,9 @@ impl WasmServiceModule {
     ) -> Result<Self, WasmExecutionError> {
         match runtime {
             #[cfg(with_wasmer)]
-            WasmRuntime::Wasmer | WasmRuntime::WasmerWithSanitizer => {
-                Self::from_wasmer(service_bytecode).await
-            }
+            WasmRuntime::Wasmer => Self::from_wasmer(service_bytecode).await,
             #[cfg(with_wasmtime)]
-            WasmRuntime::Wasmtime | WasmRuntime::WasmtimeWithSanitizer => {
-                Self::from_wasmtime(service_bytecode).await
-            }
+            WasmRuntime::Wasmtime => Self::from_wasmtime(service_bytecode).await,
         }
     }
 
@@ -209,6 +194,49 @@ impl UserServiceModule for WasmServiceModule {
     }
 }
 
+/// Instrument the [`Bytecode`] to add fuel metering.
+pub fn add_metering(bytecode: Bytecode) -> Result<Bytecode, WasmExecutionError> {
+    struct WasmtimeRules;
+
+    impl gas_metering::Rules for WasmtimeRules {
+        /// Calculates the fuel cost of a WebAssembly [`Operator`].
+        ///
+        /// The rules try to follow the hardcoded [rules in the Wasmtime runtime
+        /// engine](https://docs.rs/wasmtime/5.0.0/wasmtime/struct.Store.html#method.add_fuel).
+        fn instruction_cost(
+            &self,
+            instruction: &parity_wasm::elements::Instruction,
+        ) -> Option<u32> {
+            use parity_wasm::elements::Instruction::*;
+
+            Some(match instruction {
+                Nop | Drop | Block(_) | Loop(_) | Unreachable | Else | End => 0,
+                _ => 1,
+            })
+        }
+
+        fn memory_grow_cost(&self) -> gas_metering::MemoryGrowCost {
+            gas_metering::MemoryGrowCost::Free
+        }
+
+        fn call_per_local_cost(&self) -> u32 {
+            0
+        }
+    }
+
+    let instrumented_module = gas_metering::inject(
+        parity_wasm::deserialize_buffer(&bytecode.bytes)?,
+        gas_metering::host_function::Injector::new(
+            "linera:app/contract-runtime-api",
+            "consume-fuel",
+        ),
+        &WasmtimeRules,
+    )
+    .map_err(|_| WasmExecutionError::InstrumentModule)?;
+
+    Ok(Bytecode::new(instrumented_module.into_bytes()?))
+}
+
 #[cfg(web)]
 const _: () = {
     use js_sys::wasm_bindgen::JsValue;
@@ -277,6 +305,10 @@ pub enum WasmExecutionError {
     LoadContractModule(#[source] anyhow::Error),
     #[error("Failed to load service Wasm module: {_0}")]
     LoadServiceModule(#[source] anyhow::Error),
+    #[error("Failed to instrument Wasm module to add fuel metering")]
+    InstrumentModule,
+    #[error("Invalid Wasm module")]
+    InvalidBytecode(#[from] wasm_instrument::parity_wasm::SerializationError),
     #[cfg(with_wasmer)]
     #[error("Failed to instantiate Wasm module: {_0}")]
     InstantiateModuleWithWasmer(#[from] Box<::wasmer::InstantiationError>),