@crowdedkingdoms/ckx-kit 0.0.0-stage → 0.1.0-dev.1

package/tools/instrument/src/main.rs

@@ -0,0 +1,165 @@
+//! Compute-module instrumentation CLI (production version of the Phase 0
+//! spike tool). Pipeline stage between `cargo build` and `wasm-opt`:
+//!
+//! Usage: instrument <input.wasm> <output.wasm> [--max-memory-mb N]
+//!
+//! 1. Validates the module's import surface against the platform allowlist
+//!    (the `ck` host API + the minimal deterministic WASI stub set).
+//! 2. Clamps the module's linear-memory maximum to `--max-memory-mb` (worker
+//!    resourceLimits do NOT cover wasm memory — this is the real cap).
+//! 3. Injects mutable-global gas metering (exported global `ck_fuel`):
+//!    every metered block decrements the global; on exhaustion the global is
+//!    set to the u64::MAX sentinel and the module traps (`unreachable`).
+//!    The host sets/reads `ck_fuel` around each entry call.
+
+use anyhow::{bail, Context, Result};
+use radix_wasm_instrument::gas_metering::{inject, mutable_global, ConstantCostRules};
+use radix_wasm_instrument::utils::module_info::ModuleInfo;
+use wasmparser::{Parser, Payload, TypeRef};
+
+const WASM_PAGE_BYTES: u64 = 65536;
+
+const ALLOWED_CK_IMPORTS: &[&str] =
+    &["log", "now_ms", "state_get", "state_set", "host_call"];
+const ALLOWED_WASI_IMPORTS: &[&str] = &[
+    "environ_get",
+    "environ_sizes_get",
+    "fd_write",
+    "proc_exit",
+    "clock_time_get",
+    "random_get",
+];
+
+fn validate_imports(wasm: &[u8]) -> Result<()> {
+    for payload in Parser::new(0).parse_all(wasm) {
+        if let Payload::ImportSection(reader) = payload? {
+            for import in reader {
+                let import = import?;
+                if !matches!(import.ty, TypeRef::Func(_)) {
+                    bail!("non-function import {}::{} not allowed", import.module, import.name);
+                }
+                let allowed = match import.module {
+                    "ck" => ALLOWED_CK_IMPORTS.contains(&import.name),
+                    "wasi_snapshot_preview1" => ALLOWED_WASI_IMPORTS.contains(&import.name),
+                    _ => false,
+                };
+                if !allowed {
+                    bail!("import {}::{} not in allowlist", import.module, import.name);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Rewrite the memory section so every defined memory carries a maximum of at
+/// most `max_pages`. Rebuilds just the memory section bytes and splices them
+/// into the module (sections are independently sized, so this is safe).
+fn clamp_memory(wasm: &[u8], max_pages: u64) -> Result<Vec<u8>> {
+    let mut mem_section_range: Option<std::ops::Range<usize>> = None;
+    let mut memories: Vec<wasmparser::MemoryType> = Vec::new();
+
+    for payload in Parser::new(0).parse_all(wasm) {
+        if let Payload::MemorySection(reader) = payload? {
+            mem_section_range = Some(reader.range());
+            for mem in reader {
+                memories.push(mem?);
+            }
+        }
+    }
+    let Some(range) = mem_section_range else {
+        // No defined memory (e.g. imported) -- nothing to clamp; the import
+        // gate already rejects non-function imports, so this cannot happen
+        // for accepted modules.
+        return Ok(wasm.to_vec());
+    };
+
+    let mut section = wasm_encoder::MemorySection::new();
+    for mem in &memories {
+        if mem.memory64 || mem.shared {
+            bail!("memory64/shared memories are not allowed");
+        }
+        if mem.initial > max_pages {
+            bail!(
+                "module declares initial memory of {} pages (> clamp of {} pages)",
+                mem.initial,
+                max_pages
+            );
+        }
+        let clamped_max = mem.maximum.map_or(max_pages, |m| m.min(max_pages));
+        section.memory(wasm_encoder::MemoryType {
+            minimum: mem.initial,
+            maximum: Some(clamped_max),
+            memory64: false,
+            shared: false,
+        });
+    }
+
+    // Encode the replacement section (id byte + LEB size + payload).
+    let mut replacement = Vec::new();
+    wasm_encoder::Section::append_to(&section, &mut replacement);
+
+    // `range` covers the section payload (not the id/size header). Locate the
+    // header: it ends where the payload begins. The id byte for the memory
+    // section is 5; scan backwards over the LEB128 size.
+    let payload_start = range.start;
+    let mut header_start = payload_start - 1;
+    // size LEB: walk back while continuation bit set on the previous byte.
+    while header_start > 0 && wasm[header_start - 1] & 0x80 != 0 {
+        header_start -= 1;
+    }
+    header_start -= 1; // the section id byte
+    if wasm[header_start] != 5 {
+        bail!("failed to locate memory section header");
+    }
+
+    let mut out = Vec::with_capacity(wasm.len() + 8);
+    out.extend_from_slice(&wasm[..header_start]);
+    out.extend_from_slice(&replacement);
+    out.extend_from_slice(&wasm[range.end..]);
+    Ok(out)
+}
+
+fn main() -> Result<()> {
+    let args: Vec<String> = std::env::args().collect();
+    let (input, output, max_memory_mb) = match args.as_slice() {
+        [_, i, o] => (i.clone(), o.clone(), 64u64),
+        [_, i, o, flag, n] if flag == "--max-memory-mb" => (
+            i.clone(),
+            o.clone(),
+            n.parse::<u64>().context("parsing --max-memory-mb")?,
+        ),
+        _ => bail!("usage: instrument <input.wasm> <output.wasm> [--max-memory-mb N]"),
+    };
+    if max_memory_mb == 0 {
+        bail!("--max-memory-mb must be >= 1");
+    }
+    let max_pages = (max_memory_mb * 1024 * 1024) / WASM_PAGE_BYTES;
+
+    let wasm = std::fs::read(&input).with_context(|| format!("reading {input}"))?;
+    validate_imports(&wasm)?;
+    let clamped = clamp_memory(&wasm, max_pages)?;
+    wasmparser::validate(&clamped).context("validating memory-clamped module")?;
+
+    let mut info =
+        ModuleInfo::new(&clamped).map_err(|e| anyhow::anyhow!("parsing module: {e:?}"))?;
+    let backend = mutable_global::Injector::new("env", "ck_fuel");
+    // Uniform cost of 1 per instruction; production per-instruction weights
+    // are Phase 10 load-test work (the fuel scale is calibrated in policy).
+    let instrumented = inject(&mut info, backend, &ConstantCostRules::default())
+        .context("injecting gas metering")?;
+
+    wasmparser::validate(&instrumented).context("validating instrumented module")?;
+
+    std::fs::write(&output, &instrumented).with_context(|| format!("writing {output}"))?;
+    eprintln!(
+        "instrumented {} ({} bytes) -> {} ({} bytes, +{:.1}%, memory max {} pages)",
+        input,
+        wasm.len(),
+        output,
+        instrumented.len(),
+        (instrumented.len() as f64 / wasm.len() as f64 - 1.0) * 100.0,
+        max_pages
+    );
+    Ok(())
+}

package/vendor.lock

@@ -0,0 +1,167 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "ckx-sdk"
+version = "0.8.0"
+dependencies = [
+ "base64",
+ "rmp-serde",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "crowdy-client-sdk"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rmp"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "rmp-serde"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
+dependencies = [
+ "rmp",
+ "serde",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+
+[[package]]
+name = "vendor-superset"
+version = "0.0.1"
+dependencies = [
+ "ckx-sdk",
+ "crowdy-client-sdk",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"