feat(typeck): upgrade const eval to full U256 precision

Author: tars-swarm[bot]

crates/typeck/Cargo.toml

@@ -16,9 +16,12 @@ indexmap = { workspace = true }
 tiny-keccak = { workspace = true }
 alloy-primitives = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+ruint = { workspace = true }
 
 [dev-dependencies]
 edge-driver = { workspace = true }
+edge-lexer = { workspace = true }
+edge-parser = { workspace = true }
 serde_json = { workspace = true }
 
 [lints]

crates/typeck/src/checker.rs

@@ -14,6 +14,7 @@ use edge_ast::{
     Program,
 };
 use indexmap::IndexMap;
+use ruint::aliases::U256;
 use tiny_keccak::{Hasher, Keccak};
 
 /// Storage slot assignment for contract fields
@@ -28,8 +29,8 @@ pub struct StorageLayout {
 pub struct ConstValue {
     /// Constant name
     pub name: String,
-    /// Resolved u256 value (fits in u64 for simple literals)
-    pub value: u64,
+    /// Resolved value as big-endian 256-bit bytes
+    pub value: [u8; 32],
 }
 
 /// A function's type information
@@ -179,12 +180,12 @@ impl TypeChecker {
             .collect();
 
         // Process constants (evaluate simple literal/arithmetic expressions)
-        let mut const_env: IndexMap<String, u64> = IndexMap::new();
+        let mut const_env: IndexMap<String, [u8; 32]> = IndexMap::new();
         let consts = contract
             .consts
             .iter()
             .map(|(decl, expr)| {
-                let value = Self::eval_const_expr(expr, &const_env).unwrap_or(0);
+                let value = Self::eval_const_expr(expr, &const_env).unwrap_or([0u8; 32]);
                 const_env.insert(decl.name.name.clone(), value);
                 ConstValue {
                     name: decl.name.name.clone(),
@@ -293,54 +294,103 @@ impl TypeChecker {
         }
     }
 
-    /// Evaluate a constant expression to a u64 value.
+    /// Evaluate a constant expression to a 256-bit value.
     /// Supports literals and simple arithmetic over previously-defined constants.
-    fn eval_const_expr(expr: &Expr, env: &IndexMap<String, u64>) -> Option<u64> {
+    /// Uses U256 arithmetic to match EVM semantics (256-bit wrapping).
+    fn eval_const_expr(expr: &Expr, env: &IndexMap<String, [u8; 32]>) -> Option<[u8; 32]> {
         match expr {
             Expr::Literal(lit) => match lit.as_ref() {
-                Lit::Int(bytes, _, _) => {
-                    // Values >u64 can't be evaluated here yet — return None
-                    // rather than silently truncating. Full U256 const eval
-                    // is planned as part of issue #43.
-                    if bytes[..24].iter().any(|&b| b != 0) {
-                        return None;
+                Lit::Int(bytes, _, _) => Some(*bytes),
+                Lit::Bool(b, _) => {
+                    let mut result = [0u8; 32];
+                    if *b {
+                        result[31] = 1;
                     }
-                    Some(u64::from_be_bytes(bytes[24..32].try_into().unwrap()))
+                    Some(result)
                 }
-                Lit::Bool(b, _) => Some(if *b { 1 } else { 0 }),
                 Lit::Hex(bytes, _) | Lit::Bin(bytes, _) => {
-                    let mut v = 0u64;
-                    for &b in bytes.iter().take(8) {
-                        v = (v << 8) | (b as u64);
-                    }
-                    Some(v)
+                    let mut result = [0u8; 32];
+                    let len = bytes.len().min(32);
+                    result[32 - len..].copy_from_slice(&bytes[..len]);
+                    Some(result)
                 }
                 Lit::Str(_, _) => None,
             },
             Expr::Ident(id) => env.get(&id.name).copied(),
             Expr::Paren(inner, _) => Self::eval_const_expr(inner, env),
             Expr::Binary(lhs, op, rhs, _) => {
-                let l = Self::eval_const_expr(lhs, env)?;
-                let r = Self::eval_const_expr(rhs, env)?;
-                match op {
-                    BinOp::Add => Some(l.wrapping_add(r)),
-                    BinOp::Sub => Some(l.wrapping_sub(r)),
-                    BinOp::Mul => Some(l.wrapping_mul(r)),
-                    BinOp::Div if r != 0 => Some(l / r),
-                    BinOp::Mod if r != 0 => Some(l % r),
-                    BinOp::BitwiseAnd => Some(l & r),
-                    BinOp::BitwiseOr => Some(l | r),
-                    BinOp::BitwiseXor => Some(l ^ r),
-                    BinOp::Shl => Some(l << (r & 63)),
-                    BinOp::Shr => Some(l >> (r & 63)),
-                    BinOp::Eq => Some(if l == r { 1 } else { 0 }),
-                    BinOp::Neq => Some(if l != r { 1 } else { 0 }),
-                    BinOp::Lt => Some(if l < r { 1 } else { 0 }),
-                    BinOp::Gt => Some(if l > r { 1 } else { 0 }),
-                    BinOp::Lte => Some(if l <= r { 1 } else { 0 }),
-                    BinOp::Gte => Some(if l >= r { 1 } else { 0 }),
-                    _ => None,
-                }
+                let l_bytes = Self::eval_const_expr(lhs, env)?;
+                let r_bytes = Self::eval_const_expr(rhs, env)?;
+                let l = U256::from_be_bytes(l_bytes);
+                let r = U256::from_be_bytes(r_bytes);
+                let result = match op {
+                    BinOp::Add => l.wrapping_add(r),
+                    BinOp::Sub => l.wrapping_sub(r),
+                    BinOp::Mul => l.wrapping_mul(r),
+                    BinOp::Div if !r.is_zero() => l / r,
+                    BinOp::Mod if !r.is_zero() => l % r,
+                    BinOp::BitwiseAnd => l & r,
+                    BinOp::BitwiseOr => l | r,
+                    BinOp::BitwiseXor => l ^ r,
+                    BinOp::Shl => {
+                        if r >= U256::from(256) {
+                            U256::ZERO
+                        } else {
+                            l << r.to::<usize>()
+                        }
+                    }
+                    BinOp::Shr => {
+                        if r >= U256::from(256) {
+                            U256::ZERO
+                        } else {
+                            l >> r.to::<usize>()
+                        }
+                    }
+                    BinOp::Eq => {
+                        if l == r {
+                            U256::from(1)
+                        } else {
+                            U256::ZERO
+                        }
+                    }
+                    BinOp::Neq => {
+                        if l != r {
+                            U256::from(1)
+                        } else {
+                            U256::ZERO
+                        }
+                    }
+                    BinOp::Lt => {
+                        if l < r {
+                            U256::from(1)
+                        } else {
+                            U256::ZERO
+                        }
+                    }
+                    BinOp::Gt => {
+                        if l > r {
+                            U256::from(1)
+                        } else {
+                            U256::ZERO
+                        }
+                    }
+                    BinOp::Lte => {
+                        if l <= r {
+                            U256::from(1)
+                        } else {
+                            U256::ZERO
+                        }
+                    }
+                    BinOp::Gte => {
+                        if l >= r {
+                            U256::from(1)
+                        } else {
+                            U256::ZERO
+                        }
+                    }
+                    _ => return None,
+                };
+                Some(result.to_be_bytes())
             }
             _ => None,
         }

crates/typeck/tests/const_eval.rs

@@ -0,0 +1,87 @@
+#![allow(missing_docs)]
+
+use std::path::PathBuf;
+
+use edge_typeck::{ConstValue, TypeChecker};
+
+/// Helper: parse + typecheck Edge source and return const values.
+fn compile_consts(source: &str) -> Vec<ConstValue> {
+    let ast = edge_parser::parse(source).expect("parse failed");
+    let checked = TypeChecker::new().check(&ast).expect("typecheck failed");
+
+    checked
+        .contracts
+        .into_iter()
+        .flat_map(|c| c.consts)
+        .collect()
+}
+
+/// Convert a [u8; 32] big-endian value to a hex string for easier assertions.
+fn to_hex(bytes: &[u8; 32]) -> String {
+    bytes.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+#[test]
+fn large_literal_above_u64_max() {
+    // 10^21 = 0x3635C9ADC5DEA00000 — larger than u64::MAX
+    let consts = compile_consts(
+        r#"contract Test {
+            const X: u256 = 1000000000000000000000;
+        }"#,
+    );
+    assert_eq!(consts.len(), 1);
+    assert_eq!(consts[0].name, "X");
+
+    let hex = to_hex(&consts[0].value);
+    assert!(
+        hex.ends_with("3635c9adc5dea00000"),
+        "expected 10^21, got 0x{hex}"
+    );
+}
+
+#[test]
+fn const_arithmetic_multiplication() {
+    let consts = compile_consts(
+        r#"contract Test {
+            const A: u256 = 100;
+            const B: u256 = A * A;
+        }"#,
+    );
+    assert_eq!(consts.len(), 2);
+    assert_eq!(consts[1].name, "B");
+    // 100 * 100 = 10000 = 0x2710
+    assert_eq!(consts[1].value[31], 0x10);
+    assert_eq!(consts[1].value[30], 0x27);
+    assert!(consts[1].value[..30].iter().all(|&b| b == 0));
+}
+
+#[test]
+fn shift_left_128_not_zero() {
+    let consts = compile_consts(
+        r#"contract Test {
+            const S: u256 = 1 << 128;
+        }"#,
+    );
+    assert_eq!(consts.len(), 1);
+    assert_eq!(consts[0].name, "S");
+    assert!(
+        consts[0].value.iter().any(|&b| b != 0),
+        "1 << 128 should not be zero"
+    );
+    // Byte at index 15 (big-endian): bit 128 = byte 16 from end = index 15
+    assert_eq!(consts[0].value[15], 1, "bit 128 should be set");
+    assert!(consts[0].value[16..].iter().all(|&b| b == 0));
+}
+
+#[test]
+fn small_value_u8() {
+    let consts = compile_consts(
+        r#"contract Test {
+            const X: u8 = 42;
+        }"#,
+    );
+    assert_eq!(consts.len(), 1);
+    assert_eq!(consts[0].name, "X");
+    assert_eq!(consts[0].value[31], 42);
+    assert!(consts[0].value[..31].iter().all(|&b| b == 0));
+}