Merge branch 'foundry-rs:master' into master

Author: Dargon789

Cargo.lock

@@ -638,7 +638,7 @@ impl NodeConfig {
     pub fn set_chain_id(&mut self, chain_id: Option<impl Into<u64>>) {
         self.chain_id = chain_id.map(Into::into);
         let chain_id = self.get_chain_id();
-        self.networks.with_chain_id(chain_id);
+        self.networks = self.networks.with_chain_id(chain_id);
         self.genesis_accounts.iter_mut().for_each(|wallet| {
             *wallet = wallet.clone().with_chain_id(Some(chain_id));
         });
@@ -1774,4 +1774,13 @@ mod tests {
         let config = PruneStateHistoryConfig::from_args(Some(Some(10)));
         assert!(config.is_state_history_supported());
     }
+
+    #[cfg(feature = "optimism")]
+    #[test]
+    fn set_chain_id_updates_network_config() {
+        let mut config = NodeConfig::test();
+        config.set_chain_id(Some(10u64));
+
+        assert!(config.networks.is_optimism());
+    }
 }

crates/anvil/src/config.rs

@@ -0,0 +1,207 @@
+//! Shared JSON output primitives for Foundry CLIs.
+
+use eyre::Result;
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, to_string};
+
+/// The current version of Foundry's top-level JSON output envelope.
+pub const JSON_SCHEMA_VERSION: u32 = 1;
+
+/// Stable top-level envelope for complete machine-readable command output.
+///
+/// This envelope represents a terminal command outcome. Long-running commands
+/// that stream intermediate records should use a separate event type and reserve
+/// this shape for final, complete results.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct JsonEnvelope<T> {
+    /// Version of the envelope schema.
+    pub schema_version: u32,
+    /// Whether the command completed successfully.
+    ///
+    /// Only meaningful for a complete/terminal command outcome.
+    pub success: bool,
+    /// Command-specific payload.
+    pub data: Option<T>,
+    /// Structured errors emitted by the command.
+    pub errors: Vec<JsonMessage>,
+    /// Structured warnings emitted by the command.
+    pub warnings: Vec<JsonMessage>,
+}
+
+impl<T> JsonEnvelope<T> {
+    /// Creates a successful envelope with command-specific data.
+    pub const fn success(data: T) -> Self {
+        Self {
+            schema_version: JSON_SCHEMA_VERSION,
+            success: true,
+            data: Some(data),
+            errors: Vec::new(),
+            warnings: Vec::new(),
+        }
+    }
+
+    /// Creates a successful envelope with command-specific data and warnings.
+    pub const fn success_with_warnings(data: T, warnings: Vec<JsonMessage>) -> Self {
+        Self {
+            schema_version: JSON_SCHEMA_VERSION,
+            success: true,
+            data: Some(data),
+            errors: Vec::new(),
+            warnings,
+        }
+    }
+}
+
+impl JsonEnvelope<()> {
+    /// Creates a failed envelope with one structured error.
+    pub fn error(error: JsonMessage) -> Self {
+        Self::failure(vec![error])
+    }
+
+    /// Creates a failed envelope with structured errors.
+    pub const fn failure(errors: Vec<JsonMessage>) -> Self {
+        Self {
+            schema_version: JSON_SCHEMA_VERSION,
+            success: false,
+            data: None,
+            errors,
+            warnings: Vec::new(),
+        }
+    }
+}
+
+/// Severity level for a structured JSON diagnostic.
+///
+/// These levels classify diagnostics attached to an envelope. Progress,
+/// informational, and debug records should be modeled as command output data or
+/// stream events instead.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum JsonMessageLevel {
+    /// Error message.
+    Error,
+    /// Warning message.
+    Warning,
+}
+
+/// Structured diagnostic entry for JSON output.
+///
+/// Diagnostics describe errors and warnings associated with command output. They
+/// are not intended for progress, informational, or debug events.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct JsonMessage {
+    /// Diagnostic severity level.
+    pub level: JsonMessageLevel,
+    /// Stable machine-readable diagnostic code.
+    pub code: String,
+    /// Human-readable diagnostic message.
+    pub message: String,
+    /// Optional structured context for the diagnostic.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub details: Option<Value>,
+}
+
+impl JsonMessage {
+    /// Creates a structured error without details.
+    pub fn error(code: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            level: JsonMessageLevel::Error,
+            code: code.into(),
+            message: message.into(),
+            details: None,
+        }
+    }
+
+    /// Creates a structured warning without details.
+    pub fn warning(code: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            level: JsonMessageLevel::Warning,
+            code: code.into(),
+            message: message.into(),
+            details: None,
+        }
+    }
+
+    /// Adds structured details to the diagnostic.
+    pub fn with_details(mut self, details: Value) -> Self {
+        self.details = Some(details);
+        self
+    }
+}
+
+/// Prints a value as compact, single-line JSON to stdout.
+///
+/// The trailing newline makes this suitable for NDJSON streams when each call
+/// emits one self-contained JSON record.
+pub fn print_json<T: Serialize>(value: &T) -> Result<()> {
+    sh_println!("{}", to_string(value)?)?;
+    Ok(())
+}
+
+/// Prints a successful JSON envelope to stdout.
+pub fn print_json_success<T: Serialize>(data: T) -> Result<()> {
+    print_json(&JsonEnvelope::success(data))
+}
+
+/// Prints a successful JSON envelope with warnings to stdout.
+pub fn print_json_success_with_warnings<T: Serialize>(
+    data: T,
+    warnings: Vec<JsonMessage>,
+) -> Result<()> {
+    print_json(&JsonEnvelope::success_with_warnings(data, warnings))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{json, to_value};
+
+    #[derive(Serialize)]
+    struct BuildData {
+        contracts: usize,
+    }
+
+    #[test]
+    fn success_envelope_serializes_all_top_level_fields() {
+        let envelope = JsonEnvelope::success(BuildData { contracts: 2 });
+
+        let json = to_string(&envelope).unwrap();
+
+        assert_eq!(
+            json,
+            r#"{"schema_version":1,"success":true,"data":{"contracts":2},"errors":[],"warnings":[]}"#
+        );
+    }
+
+    #[test]
+    fn warning_details_are_structured() {
+        let warning = JsonMessage::warning("compiler.remappings", "auto-detected remappings")
+            .with_details(json!({ "count": 3 }));
+        let envelope =
+            JsonEnvelope::success_with_warnings(BuildData { contracts: 1 }, vec![warning]);
+
+        let value = to_value(&envelope).unwrap();
+
+        assert_eq!(value["success"], true);
+        assert_eq!(value["warnings"][0]["level"], "warning");
+        assert_eq!(value["warnings"][0]["code"], "compiler.remappings");
+        assert_eq!(value["warnings"][0]["details"]["count"], 3);
+    }
+
+    #[test]
+    fn failure_envelope_serializes_null_data_and_structured_errors() {
+        let error = JsonMessage::error("config.invalid", "invalid foundry.toml")
+            .with_details(json!({ "path": "foundry.toml" }));
+        let envelope = JsonEnvelope::error(error);
+
+        let value = to_value(&envelope).unwrap();
+
+        assert_eq!(value["schema_version"], JSON_SCHEMA_VERSION);
+        assert_eq!(value["success"], false);
+        assert!(value["data"].is_null());
+        assert_eq!(value["errors"][0]["level"], "error");
+        assert_eq!(value["errors"][0]["code"], "config.invalid");
+        assert_eq!(value["errors"][0]["details"]["path"], "foundry.toml");
+        assert_eq!(value["warnings"], json!([]));
+    }
+}

crates/cli/src/json.rs

@@ -13,6 +13,7 @@ extern crate tracing;
 
 pub mod clap;
 pub mod handler;
+pub mod json;
 pub mod opts;
 pub mod utils;
 

crates/cli/src/lib.rs

@@ -18,6 +18,7 @@ foundry-common.workspace = true
 foundry-compilers.workspace = true
 foundry-config.workspace = true
 
+alloy-primitives.workspace = true
 solar.workspace = true
 
 eyre.workspace = true

crates/lint/Cargo.toml

@@ -44,6 +44,7 @@ It helps enforce best practices and improve code quality within Foundry projects
   - `low-level-calls`: Direct use of low-level calls should be avoided.
 - **Gas Optimizations:**
   - `asm-keccak256`: Recommends using inline assembly for `keccak256` for potential gas savings.
+  - `costly-loop`: Flags storage variable writes inside loops; accumulate into a local variable and write once after the loop instead.
   - `could-be-immutable`: Recommends declaring constructor-only state variables as `immutable`.
   - `custom-errors`: Recommends using custom errors instead of strings and plain reverts for potential gas savings.
   - `unused-state-variables`: State variables that are never used should be removed.

crates/lint/README.md

@@ -0,0 +1,57 @@
+# Costly operations inside a loop
+
+**Severity**: `Gas`
+**ID**: `costly-loop`
+
+Flags storage variable writes inside loops. Each SSTORE costs at least 2,900 gas (warm) or 20,000
+gas (cold), so writing to storage on every loop iteration can be extremely expensive. Accumulating
+the result in a local memory variable and writing to storage once after the loop is the standard
+optimization.
+
+## What it does
+
+Reports assignments, compound assignments, increments/decrements, and `delete` expressions that
+directly write to a storage variable inside any `for`, `while`, or `do-while` loop body, including
+writes through storage array indices and mapping keys.
+
+## Why is this bad?
+
+SSTORE is one of the most expensive EVM opcodes. Writing to storage in a loop multiplies that cost
+by the number of iterations and can easily cause transactions to run out of gas or become
+economically impractical.
+
+## Example
+
+### Bad
+
+```solidity
+contract C {
+    uint256 public counter;
+
+    function bad(uint256 n) external {
+        for (uint256 i = 0; i < n; i++) {
+            counter++; // costly-loop: SSTORE on every iteration
+        }
+    }
+}
+```
+
+### Good
+
+```solidity
+contract C {
+    uint256 public counter;
+
+    function good(uint256 n) external {
+        uint256 local = counter;
+        for (uint256 i = 0; i < n; i++) {
+            local++;
+        }
+        counter = local; // single SSTORE after the loop
+    }
+}
+```
+
+## Notes
+
+This is a `Gas`-severity lint and is **not** applied to test or script files.

crates/lint/docs/costly-loop.md

@@ -0,0 +1,63 @@
+# Type-Based Tautology
+
+**Severity**: `Med`
+**ID**: `type-based-tautology`
+
+Detects comparison expressions that are always true or always false due to the numeric range of the variable's type. These dead conditions indicate logic errors or misunderstandings about integer bounds.
+
+## What it does
+
+Flags binary comparisons (`<`, `<=`, `>`, `>=`, `==`, `!=`) where one operand is a typed integer variable and the other is a constant that lies outside, or exactly at the boundary of the variable's representable range, making the condition unconditionally true or false.
+
+Examples:
+- `uint x >= 0` is always true because unsigned integers cannot be negative.
+- `uint8 x > 255` is always false because 255 is the maximum value of `uint8`.
+- `int8 x < -128` is always false because -128 is the minimum value of `int8`.
+- `uint8 x == 256` is always false because 256 is outside the range of `uint8`.
+- `uint8 x != 256` is always true because 256 is outside the range of `uint8`.
+
+The check also applies to explicit type casts: `uint8(x) < 256` is always true.
+
+> **Limitation:** The lint only fires when the left-hand variable is a local or state variable identifier, or an explicit cast expression (e.g. `uint8(x)`). It does not fire on struct member access (`s.field < 0`) or function return values (`foo() < 0`).
+
+## Why is this bad?
+
+A condition that is permanently true contributes no useful logic and may hide a bug where the developer intended to compare against a different value or use a differently sized type. A condition that is permanently false creates unreachable code, which can silently suppress intended behavior such as access control checks or error handling.
+
+## Example
+
+### Bad
+
+```solidity
+function isValid(uint256 x) public pure returns (bool) {
+    return x >= 0; // always true, uint cannot be negative
+}
+
+function isInRange(uint8 x) public pure returns (bool) {
+    return x < 256; // always true, uint8 max is 255
+}
+
+function isBelowMin(int8 x) public pure returns (bool) {
+    return x < -128; // always false, int8 min is -128
+}
+
+function isImpossible(uint8 x) public pure returns (bool) {
+    return x == 256; // always false, 256 is outside uint8 range
+}
+```
+
+### Good
+
+```solidity
+function isValid(uint256 x) public pure returns (bool) {
+    return x > 0; // meaningful: false when x == 0
+}
+
+function isInRange(uint8 x, uint8 limit) public pure returns (bool) {
+    return x < limit; // compare against a runtime value
+}
+
+function isBelowThreshold(int8 x) public pure returns (bool) {
+    return x < -100; // a value within the representable range
+}
+```