fix: resolve code review findings

P1: Replace unimplemented!() panic in NearTrigger::to_rust_bytes() with Vec::new()
P2: Propagate PossibleReorg errors from ipfs_cat host fn instead of swallowing them
P2: Fix useless .into() conversions on anyhow::Error (clippy useless_conversion)
P3: Apply rustfmt to all changed files
P3: Clarify comment on byte-scan Rust detection heuristic in ValidModule::new()

Build: cargo build clean
Tests: 14 rust_abi + existing wasm tests all pass
Lint: cargo clippy --deny warnings clean
Format: cargo fmt --check clean

Author: cargopete

chain/ethereum/src/runtime/runtime_adapter.rs

@@ -221,7 +221,7 @@ impl RawEthCall for EthereumRawEthCall {
                 archive: false,
                 traces: false,
             }))
-            .map_err(|e| HostExportError::Unknown(e.into()))?;
+            .map_err(HostExportError::Unknown)?;
 
         // Create a raw call request
         let req = call::Request::new(Address::from(address), calldata.to_vec(), 0);
@@ -267,15 +267,12 @@ impl RawEthCall for EthereumRawEthCall {
                     call::Retval::Null => Ok(None),
                 }
             }
-            Err(ContractCallError::AlloyError(e)) => {
-                Err(HostExportError::PossibleReorg(anyhow::anyhow!(
-                    "eth_call RPC error: {}",
-                    e
-                )))
-            }
-            Err(ContractCallError::Timeout) => Err(HostExportError::PossibleReorg(anyhow::anyhow!(
-                "eth_call timed out"
-            ))),
+            Err(ContractCallError::AlloyError(e)) => Err(HostExportError::PossibleReorg(
+                anyhow::anyhow!("eth_call RPC error: {}", e),
+            )),
+            Err(ContractCallError::Timeout) => Err(HostExportError::PossibleReorg(
+                anyhow::anyhow!("eth_call timed out"),
+            )),
             Err(e) => Err(HostExportError::Unknown(anyhow::anyhow!(
                 "eth_call failed: {}",
                 e

chain/ethereum/src/trigger.rs

@@ -23,7 +23,9 @@ use graph::runtime::AscPtr;
 use graph::runtime::HostExportError;
 use graph::semver::Version;
 use graph_runtime_wasm::module::ToAscPtr;
-use graph_runtime_wasm::rust_abi::{RustBlockTrigger, RustCallTrigger, RustLogTrigger, ToRustBytes};
+use graph_runtime_wasm::rust_abi::{
+    RustBlockTrigger, RustCallTrigger, RustLogTrigger, ToRustBytes,
+};
 use std::{cmp::Ordering, sync::Arc};
 
 use crate::runtime::abi::AscEthereumBlock;
@@ -672,13 +674,7 @@ impl ToRustBytes for MappingTrigger {
                     log_index: log.log_index.unwrap_or(0),
                     block_number: block.number_u64(),
                     block_timestamp: block.inner().header.timestamp,
-                    topics: log
-                        .inner
-                        .data
-                        .topics()
-                        .iter()
-                        .map(|t| t.0)
-                        .collect(),
+                    topics: log.inner.data.topics().iter().map(|t| t.0).collect(),
                     data: log.inner.data.data.to_vec(),
                 };
                 rust_trigger.to_rust_bytes()

chain/near/src/trigger.rs

@@ -146,9 +146,11 @@ impl MappingTriggerTrait for NearTrigger {
 
 impl ToRustBytes for NearTrigger {
     fn to_rust_bytes(&self) -> Vec<u8> {
-        // NEAR triggers are not yet supported by Graphite SDK.
-        // This stub satisfies the trait bound so Ethereum Rust subgraphs can compile.
-        unimplemented!("Rust ABI serialization is not yet supported for NEAR triggers")
+        // NEAR triggers are not yet supported by the Rust ABI.
+        // Return empty bytes rather than panicking; the handler will receive no data
+        // and can decide how to proceed. A Rust subgraph targeting NEAR would need
+        // to implement NEAR-specific serialization in a future PR.
+        Vec::new()
     }
 }
 

runtime/wasm/src/mapping.rs

@@ -273,13 +273,21 @@ impl ValidModule {
         raw_module: &[u8],
         timeout: Option<Duration>,
     ) -> Result<Self, anyhow::Error> {
-        // Detect Rust modules by scanning for the "graphite" import namespace.
-        // Rust modules use modern WASM features (bulk-memory, reference-types, etc.)
-        // that parity_wasm cannot parse, so we skip parity_wasm gas injection for them.
+        // Pre-parse detection: scan raw bytes for the "graphite" import namespace string.
+        // This is a fast heuristic used solely to decide whether to skip parity_wasm gas
+        // injection, which cannot parse modern WASM features (bulk-memory, reference-types)
+        // that Rust-compiled modules use. A false positive (an AS module containing the
+        // literal string "graphite") would be caught later: build_linker() does a proper
+        // import-map check, and invoke_handler_rust() would immediately fail with
+        // "function 'allocate' not found" rather than silently misbehaving.
+        // The authoritative language detection happens in build_linker() below.
         let is_rust_module = raw_module.windows(8).any(|w| w == b"graphite");
 
         let (raw_module, start_function) = if is_rust_module {
-            info!(logger, "Detected Rust WASM module, skipping parity_wasm gas injection");
+            info!(
+                logger,
+                "Detected Rust WASM module, skipping parity_wasm gas injection"
+            );
             (raw_module.to_vec(), None)
         } else {
             // Add the gas calls here. Module name "gas" must match. See also
@@ -317,8 +325,9 @@ impl ValidModule {
 
                 name
             });
-            let parity_module = wasm_instrument::gas_metering::inject(parity_module, &GasRules, "gas")
-                .map_err(|_| anyhow!("Failed to inject gas counter"))?;
+            let parity_module =
+                wasm_instrument::gas_metering::inject(parity_module, &GasRules, "gas")
+                    .map_err(|_| anyhow!("Failed to inject gas counter"))?;
             (parity_module.into_bytes()?, start_function)
         };
 

runtime/wasm/src/module/context.rs

@@ -1289,10 +1289,8 @@ impl WasmInstanceContext<'_> {
         }
 
         // Convert HashMap<String, Value> to HashMap<Word, Value>
-        let data: std::collections::HashMap<Word, store::Value> = data
-            .into_iter()
-            .map(|(k, v)| (Word::from(k), v))
-            .collect();
+        let data: std::collections::HashMap<Word, store::Value> =
+            data.into_iter().map(|(k, v)| (Word::from(k), v)).collect();
 
         let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
         let ctx = &mut self.as_mut().ctx;
@@ -1404,7 +1402,13 @@ impl WasmInstanceContext<'_> {
         let ctx = &mut self.as_mut().ctx;
 
         host_exports
-            .log_log(&ctx.logger, slog_level, message.to_string(), gas, &mut ctx.state)
+            .log_log(
+                &ctx.logger,
+                slog_level,
+                message.to_string(),
+                gas,
+                &mut ctx.state,
+            )
             .map_err(|e| HostExportError::Deterministic(e.into()))
     }
 
@@ -1480,6 +1484,6 @@ impl WasmInstanceContext<'_> {
         host_exports
             .ipfs_cat(&logger, hash.to_string())
             .await
-            .map_err(|e| HostExportError::PossibleReorg(e.into()))
+            .map_err(HostExportError::PossibleReorg)
     }
 }

runtime/wasm/src/module/instance.rs

@@ -218,7 +218,10 @@ impl WasmInstance {
             Ok(result_code) => {
                 if result_code != 0 {
                     // Non-zero return code indicates handler error
-                    Some(anyhow::anyhow!("handler returned error code {}", result_code))
+                    Some(anyhow::anyhow!(
+                        "handler returned error code {}",
+                        result_code
+                    ))
                 } else {
                     assert!(!self.instance_ctx().as_ref().possible_reorg);
                     assert!(!self.instance_ctx().as_ref().deterministic_host_trap);
@@ -551,7 +554,9 @@ 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: u32|
+             -> anyhow::Result<()> {
                 use graph::runtime::gas::SaturatingInto;
                 if let Err(e) = caller
                     .data()

runtime/wasm/src/rust_abi/host.rs

@@ -21,10 +21,7 @@ fn read_bytes_with_gas(
     gas: &graph::runtime::gas::GasCounter,
 ) -> Result<Vec<u8>, anyhow::Error> {
     // Charge gas for memory read
-    gas.consume_host_fn_with_metrics(
-        Gas::new(GAS_COST_LOAD as u64 * len as u64),
-        "rust_abi_read",
-    )?;
+    gas.consume_host_fn_with_metrics(Gas::new(GAS_COST_LOAD as u64 * len as u64), "rust_abi_read")?;
 
     let data = memory.data(&store);
     let start = ptr as usize;
@@ -160,8 +157,13 @@ pub fn link_rust_host_functions(
                     let memory = get_memory(&mut caller)?;
                     let gas = caller.data().gas.cheap_clone();
 
-                    let entity_type =
-                        read_string_with_gas(&memory, &caller, entity_type_ptr, entity_type_len, &gas)?;
+                    let entity_type = read_string_with_gas(
+                        &memory,
+                        &caller,
+                        entity_type_ptr,
+                        entity_type_len,
+                        &gas,
+                    )?;
                     let id = read_string_with_gas(&memory, &caller, id_ptr, id_len, &gas)?;
                     let data_bytes =
                         read_bytes_with_gas(&memory, &caller, data_ptr, data_len, &gas)?;
@@ -197,8 +199,13 @@ pub fn link_rust_host_functions(
                     let memory = get_memory(&mut caller)?;
                     let gas = caller.data().gas.cheap_clone();
 
-                    let entity_type =
-                        read_string_with_gas(&memory, &caller, entity_type_ptr, entity_type_len, &gas)?;
+                    let entity_type = read_string_with_gas(
+                        &memory,
+                        &caller,
+                        entity_type_ptr,
+                        entity_type_len,
+                        &gas,
+                    )?;
                     let id = read_string_with_gas(&memory, &caller, id_ptr, id_len, &gas)?;
 
                     // Call the actual store_get through WasmInstanceContext
@@ -233,8 +240,13 @@ pub fn link_rust_host_functions(
                     let memory = get_memory(&mut caller)?;
                     let gas = caller.data().gas.cheap_clone();
 
-                    let entity_type =
-                        read_string_with_gas(&memory, &caller, entity_type_ptr, entity_type_len, &gas)?;
+                    let entity_type = read_string_with_gas(
+                        &memory,
+                        &caller,
+                        entity_type_ptr,
+                        entity_type_len,
+                        &gas,
+                    )?;
                     let id = read_string_with_gas(&memory, &caller, id_ptr, id_len, &gas)?;
 
                     let mut ctx = std::pin::pin!(WasmInstanceContext::new(&mut caller));
@@ -393,7 +405,13 @@ pub fn link_rust_host_functions(
                                 Ok(bytes.len() as u32)
                             }
                         }
-                        Err(_) => Ok(u32::MAX), // Error indicator
+                        Err(e) => {
+                            // Propagate reorg signals as traps so the block can be retried.
+                            if let graph::runtime::HostExportError::PossibleReorg(_) = &e {
+                                caller.data_mut().possible_reorg = true;
+                            }
+                            Err(anyhow::anyhow!("ipfs_cat failed: {}", e))
+                        }
                     }
                 })
             },
@@ -438,8 +456,7 @@ pub fn link_rust_host_functions(
                     address.copy_from_slice(&addr_bytes);
 
                     // Read calldata
-                    let calldata =
-                        read_bytes_with_gas(&memory, &caller, data_ptr, data_len, &gas)?;
+                    let calldata = read_bytes_with_gas(&memory, &caller, data_ptr, data_len, &gas)?;
 
                     // Get the raw_eth_call capability from ctx
                     let raw_eth_call = caller
@@ -457,7 +474,9 @@ pub fn link_rust_host_functions(
                     let block_ptr = caller.data().ctx.block_ptr.cheap_clone();
 
                     // Make the call
-                    let result = raw_eth_call.call(address, &calldata, &block_ptr, None).await;
+                    let result = raw_eth_call
+                        .call(address, &calldata, &block_ptr, None)
+                        .await;
 
                     match result {
                         Ok(Some(bytes)) => {
@@ -503,8 +522,9 @@ pub fn link_rust_host_functions(
                 let memory = get_memory(&mut caller)?;
                 let gas = caller.data().gas.cheap_clone();
 
-                let message = read_string_with_gas(&memory, &caller, message_ptr, message_len, &gas)
-                    .unwrap_or_else(|_| "<failed to read message>".to_string());
+                let message =
+                    read_string_with_gas(&memory, &caller, message_ptr, message_len, &gas)
+                        .unwrap_or_else(|_| "<failed to read message>".to_string());
 
                 // Mark as deterministic trap
                 caller.data_mut().deterministic_host_trap = true;

runtime/wasm/src/rust_abi/trigger.rs

@@ -48,16 +48,16 @@ impl ToRustBytes for RustLogTrigger {
 impl ToRustWasm for RustLogTrigger {
     fn write_to<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         // Fixed-size fields first (no length prefix)
-        writer.write_all(&self.address)?;        // 20 bytes
-        writer.write_all(&self.tx_hash)?;        // 32 bytes
-        writer.write_all(&self.log_index.to_le_bytes())?;      // 8 bytes
-        writer.write_all(&self.block_number.to_le_bytes())?;   // 8 bytes
+        writer.write_all(&self.address)?; // 20 bytes
+        writer.write_all(&self.tx_hash)?; // 32 bytes
+        writer.write_all(&self.log_index.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.block_number.to_le_bytes())?; // 8 bytes
         writer.write_all(&self.block_timestamp.to_le_bytes())?; // 8 bytes
 
         // Topics array: count + data
         writer.write_all(&(self.topics.len() as u32).to_le_bytes())?;
         for topic in &self.topics {
-            writer.write_all(topic)?;  // 32 bytes each
+            writer.write_all(topic)?; // 32 bytes each
         }
 
         // Data: length + bytes
@@ -100,12 +100,12 @@ impl ToRustBytes for RustCallTrigger {
 impl ToRustWasm for RustCallTrigger {
     fn write_to<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         // Fixed-size fields
-        writer.write_all(&self.to)?;                              // 20 bytes
-        writer.write_all(&self.from)?;                            // 20 bytes
-        writer.write_all(&self.tx_hash)?;                         // 32 bytes
-        writer.write_all(&self.block_number.to_le_bytes())?;      // 8 bytes
-        writer.write_all(&self.block_timestamp.to_le_bytes())?;   // 8 bytes
-        writer.write_all(&self.block_hash)?;                      // 32 bytes
+        writer.write_all(&self.to)?; // 20 bytes
+        writer.write_all(&self.from)?; // 20 bytes
+        writer.write_all(&self.tx_hash)?; // 32 bytes
+        writer.write_all(&self.block_number.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.block_timestamp.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.block_hash)?; // 32 bytes
 
         // Input: length + bytes
         writer.write_all(&(self.input.len() as u32).to_le_bytes())?;
@@ -152,15 +152,15 @@ impl ToRustBytes for RustBlockTrigger {
 
 impl ToRustWasm for RustBlockTrigger {
     fn write_to<W: Write>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_all(&self.hash)?;                            // 32 bytes
-        writer.write_all(&self.parent_hash)?;                     // 32 bytes
-        writer.write_all(&self.number.to_le_bytes())?;            // 8 bytes
-        writer.write_all(&self.timestamp.to_le_bytes())?;         // 8 bytes
-        writer.write_all(&self.author)?;                          // 20 bytes
-        writer.write_all(&self.gas_used.to_le_bytes())?;          // 8 bytes
-        writer.write_all(&self.gas_limit.to_le_bytes())?;         // 8 bytes
-        writer.write_all(&self.difficulty)?;                      // 32 bytes
-        writer.write_all(&self.base_fee_per_gas.to_le_bytes())?;  // 8 bytes
+        writer.write_all(&self.hash)?; // 32 bytes
+        writer.write_all(&self.parent_hash)?; // 32 bytes
+        writer.write_all(&self.number.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.timestamp.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.author)?; // 20 bytes
+        writer.write_all(&self.gas_used.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.gas_limit.to_le_bytes())?; // 8 bytes
+        writer.write_all(&self.difficulty)?; // 32 bytes
+        writer.write_all(&self.base_fee_per_gas.to_le_bytes())?; // 8 bytes
         Ok(())
     }
 }
@@ -193,7 +193,8 @@ mod tests {
 
         // Check topics count
         let topics_offset = 20 + 32 + 24;
-        let topics_count = u32::from_le_bytes(bytes[topics_offset..topics_offset+4].try_into().unwrap());
+        let topics_count =
+            u32::from_le_bytes(bytes[topics_offset..topics_offset + 4].try_into().unwrap());
         assert_eq!(topics_count, 2);
     }
 

runtime/wasm/src/rust_abi/types.rs

@@ -211,8 +211,7 @@ impl ToRustWasm for BigDecimal {
 impl FromRustWasm for BigDecimal {
     fn read_from<R: Read>(reader: &mut R) -> io::Result<Self> {
         let s = String::read_from(reader)?;
-        BigDecimal::from_str(&s)
-            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+        BigDecimal::from_str(&s).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
     }
 }