build(deps): bump wasm-instrument from 0.2.0 to 0.4.0

Bumps [wasm-instrument](https://github.com/paritytech/wasm-instrument)
from 0.2.0 to 0.4.0.

- [Changelog](https://github.com/paritytech/wasm-instrument/blob/master/CHANGELOG.md)
- [Commits](paritytech/wasm-instrument@0.2.0...v0.4.0)

The new version switches the per-block gas counter and the
`memory.grow` charge helper from 32-bit to 64-bit arithmetic. Our call
sites were adjusted accordingly:

- `runtime/wasm/src/mapping.rs`: use the new `host_function::Injector`
  backend API for `gas_metering::inject`.
- `runtime/wasm/src/gas_rules.rs`: implement the new
  `call_per_local_cost()` method, returning 0 so locals initialization
  remains free.
- `runtime/wasm/src/module/instance.rs`: the injected `gas` host
  function now receives an `i64` cost argument instead of `i32`;
  update the Rust handler signature from `u32` to `u64`.

The 64-bit arithmetic in the grow-counter helper also fixes an
overflow that was previously under-charging gas for large
`memory.grow` calls. In 0.2.0 the helper multiplied the page count by
`gas_per_page` (~50.8M in our rules) using `I32Mul`, which wrapped
mod 2^32 for any grow larger than ~84 pages (~5.25 MiB). 0.4.0 extends
the page count to `i64` before the multiplication, so the full cost is
charged.

The two `yaml_parsing_v0_0_*` tests in `runtime/test/src/test.rs`
pin exact `gas_used` totals. The YAML input
`"x".repeat(10_000_001)` causes three large grow events, so each test
reports exactly `3 * 2^32 = 12,884,901,888` more gas than before.
Update the expected values to match the now-correct totals.

Note for downstream: this is a semantic change in gas accounting for
subgraph handlers that grow memory past ~5.25 MiB in a single call.
Such handlers will consume more gas than they did on 0.2.0; this may
warrant a release note or API-version gating, which is out of scope
for this dependency bump.

Signed-off-by: dependabot[bot] <support@github.com>

Author: dependabot[bot]

Cargo.lock

@@ -1844,10 +1844,10 @@ async fn test_yaml_parsing(api_version: Version, gas_used: u64) {
 
 #[graph::test]
 async fn yaml_parsing_v0_0_4() {
-    test_yaml_parsing(API_VERSION_0_0_4, 1053927678771).await;
+    test_yaml_parsing(API_VERSION_0_0_4, 1066812580659).await;
 }
 
 #[graph::test]
 async fn yaml_parsing_v0_0_5() {
-    test_yaml_parsing(API_VERSION_0_0_5, 1053946160531).await;
+    test_yaml_parsing(API_VERSION_0_0_5, 1066831062419).await;
 }

runtime/test/src/test.rs

@@ -14,7 +14,7 @@ anyhow = { workspace = true }
 never = "0.1"
 
 wasmtime.workspace = true
-wasm-instrument = { version = "0.2.0", features = ["std", "sign_ext"] }
+wasm-instrument = { version = "0.4.0", features = ["std", "sign_ext"] }
 
 # AssemblyScript uses sign extensions
 parity-wasm = { version = "0.45", features = ["std", "sign_ext"] }

runtime/wasm/Cargo.toml

@@ -165,4 +165,8 @@ impl Rules for GasRules {
 
         MemoryGrowCost::Linear(gas_per_page)
     }
+
+    fn call_per_local_cost(&self) -> u32 {
+        0
+    }
 }

runtime/wasm/src/gas_rules.rs

@@ -302,8 +302,10 @@ impl ValidModule {
 
             name
         });
-        let parity_module = wasm_instrument::gas_metering::inject(parity_module, &GasRules, "gas")
-            .map_err(|_| anyhow!("Failed to inject gas counter"))?;
+        let backend = wasm_instrument::gas_metering::host_function::Injector::new("gas", "gas");
+        let parity_module =
+            wasm_instrument::gas_metering::inject(parity_module, backend, &GasRules)
+                .map_err(|_| anyhow!("Failed to inject gas counter"))?;
         let raw_module = parity_module.into_bytes()?;
 
         // We use Cranelift as a compilation engine. Cranelift is an optimizing compiler, but that

runtime/wasm/src/mapping.rs

@@ -16,7 +16,7 @@ use graph::data_source::{MappingTrigger, TriggerWithHandler};
 use graph::prelude::*;
 use graph::runtime::{
     HostExportError, asc_new,
-    gas::{Gas, GasCounter, SaturatingInto},
+    gas::{Gas, GasCounter},
 };
 use graph::{components::subgraph::MappingError, runtime::AscPtr};
 
@@ -576,15 +576,15 @@ pub(crate) fn build_linker(
     linker.func_wrap(
         "gas",
         "gas",
-        |mut caller: wasmtime::Caller<'_, WasmInstanceData>, gas_used: u32| -> anyhow::Result<()> {
+        |mut caller: wasmtime::Caller<'_, WasmInstanceData>, gas_used: u64| -> anyhow::Result<()> {
             // Gas metering has a relevant execution cost cost, being called tens of thousands
             // of times per handler, but it's not worth having a stopwatch section here because
             // the cost of measuring would be greater than the cost of `consume_host_fn`. Last
             // time this was benchmarked it took < 100ns to run.
             if let Err(e) = caller
                 .data()
                 .gas
-                .consume_host_fn_with_metrics(gas_used.saturating_into(), "gas")
+                .consume_host_fn_with_metrics(Gas::new(gas_used), "gas")
             {
                 caller.data_mut().deterministic_host_trap = true;
                 return Err(e.into());