.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -2,3 +2,5 @@ onchain/cache/
 onchain/out/
 
 offchain/target/
+
+.direnv

flake.nix

@@ -25,6 +25,7 @@
             solc
             cargo
             rustc
+            rust-analyzer
           ];
 
           # Decorative prompt override so we know when we're in a dev shell

offchain/Cargo.toml

@@ -6,5 +6,13 @@ edition = "2021"
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-revm = "18.0.0"
 rand = "0.8"
+hex = "0.4"
+# ethers = { version = "2.0", features = ["abi"] }
+anyhow = "1.0"
+revm = { git = "https://github.com/bluealloy/revm.git", rev = "03ea24bd9550e93b08f343e0b410725557c1adb4", features = ["std"] }
+database = { git = "https://github.com/bluealloy/revm.git", rev = "03ea24bd9550e93b08f343e0b410725557c1adb4", package = "revm-database" }
+ethers = "2.0"
+
+
+

offchain/src/compiler/ast.rs

@@ -1,25 +1,340 @@
+// pub trait Push3Ast {
+//     /// Convert this AST into a bytecode array (Push3 tokens).
+//     fn to_bytecode(&self) -> Vec<u8>;
+
+//     // Parse an AST from bytecode (the "decompiler"), if possible.
+//     // Possibly returns a Result in case of partial/invalid parse.
+//     // fn from_bytecode(data: &[u8]) -> Self
+//     // where
+//     //     Self: Sized;
+
+//     // Randomly mutate this AST in-place (GP mutation).
+//     // fn mutate(&mut self, rng: &mut impl rand::Rng);
+
+//     // Possibly a "crossover" method, or we do it externally.
+//     // fn crossover(&self, other: &Self, rng: &mut impl rand::Rng) -> Self;
+
+//     // Evaluate the AST with some input(s).
+//     // Optionally do we want this or do we always run in EVM? 
+//     // We can stub it or do an interpret approach for local test.
+//     // fn interpret_locally(&self, inputs: &[i32]) -> Vec<i32>;
+// }
+
+
+// #[derive(Debug, Clone)]
+// pub enum TypedAst {
+//     IntLiteral(i32),
+//     Instruction(InstructionKind),
+// }
+
+// #[derive(Debug, Clone)]
+// pub enum InstructionKind {
+//     Plus(Box<TypedAst>, Box<TypedAst>),
+//     Minus(Box<TypedAst>, Box<TypedAst>),
+//     Mult(Box<TypedAst>, Box<TypedAst>),
+//     Dup,  // 0 children
+//     Pop,  // 0 children
+// }
+
+// impl Push3Ast for TypedAst {
+//     fn to_bytecode(&self) -> Vec<u8> {
+//         // do typed encoding: 
+//         // - for Plus(e1, e2): e1 -> bytecode, e2 -> bytecode, then PLUS opcode
+//         unimplemented!()
+//     }
+
+//     // fn from_bytecode(data: &[u8]) -> Self {
+//     //     // parse in a strictly typed manner; might fail or panic 
+//     //     // if the code doesn't line up properly
+//     //     unimplemented!()
+//     // }
+
+//     // fn mutate(&mut self, rng: &mut impl rand::Rng) {
+//     //     // e.g. randomly pick a node, replace it with something 
+//     //     // that respects the typed structure
+//     //     unimplemented!()
+//     // }
+
+//     // fn interpret_locally(&self, inputs: &[i32]) -> Vec<i32> {
+//     //     // do a normal expression evaluation. If a node is "Plus(a,b)",
+//     //     // interpret (a) + interpret(b).
+//     //     unimplemented!()
+//     // }
+// }
+
+// #[derive(Debug, Clone)]
+// pub enum UntypedAst {
+//     /// A single token in a list-based approach, e.g. "Integer literal"
+//     IntLiteral(i32),
+
+//     /// "Instruction" might be a simple variant with no children, 
+//     /// because the stack-based evaluation decides how many arguments it consumes.
+//     Instruction(OpCode),  
+
+//     /// A sublist of tokens, e.g. "( 2 3 DUP + )"
+//     Sublist(Vec<UntypedAst>),
+// }
+
+// /// Possibly an enum for OpCode:
+// #[derive(Debug, Clone)]
+// pub enum OpCode {
+//     Noop,
+//     Plus,
+//     Minus,
+//     Mult,
+//     Dup,
+//     Pop,
+//     // maybe Unknown => treat as no-op
+// }
+
+// // impl Push3Ast for UntypedAst {
+// //     fn to_bytecode(&self) -> Vec<u8> {
+// //         // flatten out sublists vs instructions
+// //         unimplemented!()
+// //     }
+
+// //     // fn from_bytecode(data: &[u8]) -> Self {
+// //     //     // parse "0x02 => INT_LITERAL => read next 4 bytes" 
+// //     //     // instructions might have no subchildren
+// //     //     unimplemented!()
+// //     // }
+
+// //     // fn mutate(&mut self, rng: &mut impl rand::Rng) {
+// //     //     // can randomly insert unknown tokens, reorder sublists, etc.
+// //     //     // possibly produce "invalid ops => noops"
+// //     //     unimplemented!()
+// //     // }
+
+// //     // fn interpret_locally(&self, inputs: &[i32]) -> Vec<i32> {
+// //     //     // push-based interpretation:
+// //     //     // sublist => interpret each item in sequence
+// //     //     // if an instruction sees insufficient args => no-op
+// //     //     unimplemented!()
+// //     // }
+// // }
+
+// use crate::compiler::ast::Push3Ast;
+
+// /// An untyped AST node, matching your Push3 structure.
+// #[derive(Debug, Clone)]
+// pub enum UntypedAst {
+//     /// A single integer literal.
+//     IntLiteral(i32),
+//     /// A single push instruction (no subchildren).
+//     Instruction(OpCode),
+//     /// A sublist of items, each of which is another UntypedAst.
+//     Sublist(Vec<UntypedAst>),
+// }
+
+// /// Your Push3 opcodes in an untyped form.
+// #[derive(Debug, Clone)]
+// pub enum OpCode {
+//     Noop,
+//     Plus,
+//     Minus,
+//     Mult,
+//     Dup,
+//     Pop,
+// }
+
+// /// Implementation of `Push3Ast` for `UntypedAst`.
+// ///
+// /// This will produce **bytecode** compatible with your Solidity `Push3Interpreter`:
+// /// 
+// /// - `0x00` => NOOP
+// /// - `0x01` => INTEGER_PLUS
+// /// - `0x02` => INT_LITERAL => next 4 bytes (little-endian i32)
+// /// - `0x03` => SUBLIST => next 2 bytes (big-endian `u16` length), then the sublist contents
+// /// - `0x04` => INTEGER_MINUS
+// /// - `0x05` => INTEGER_MULT
+// /// - `0x06` => INTEGER_DUP
+// /// - `0x07` => INTEGER_POP
+// ///
+// /// In the Solidity parser, `SUBLIST (0x03)` consumes two bytes to determine
+// /// how many bytes of tokens to read in that sublist.
+// impl Push3Ast for UntypedAst {
+//     /// Convert this untyped AST into a flattened push3 bytecode sequence.
+//     fn to_bytecode(&self) -> Vec<u8> {
+//         match self {
+//             UntypedAst::IntLiteral(val) => {
+//                 // 0x02 followed by 4 bytes of i32 (little-endian)
+//                 let mut bytes = Vec::with_capacity(1 + 4);
+//                 bytes.push(0x02);
+//                 bytes.extend_from_slice(&val.to_le_bytes());
+//                 bytes
+//             }
+//             UntypedAst::Instruction(op) => {
+//                 // Single opcode byte
+//                 let opcode_byte = match op {
+//                     OpCode::Noop  => 0x00,
+//                     OpCode::Plus  => 0x01,
+//                     OpCode::Minus => 0x04,
+//                     OpCode::Mult  => 0x05,
+//                     OpCode::Dup   => 0x06,
+//                     OpCode::Pop   => 0x07,
+//                 };
+//                 vec![opcode_byte]
+//             }
+//             UntypedAst::Sublist(children) => {
+//                 // 0x03 => SUBLIST
+//                 // Then 2 bytes for length (big-endian u16),
+//                 // Then the concatenated bytecode for all children.
+//                 let mut payload = Vec::new();
+//                 for child in children {
+//                     let child_bytes = child.to_bytecode();
+//                     payload.extend_from_slice(&child_bytes);
+//                 }
+//                 let sub_len = payload.len() as u16; // assume it fits in 65535
+//                 let mut bytes = Vec::with_capacity(1 + 2 + payload.len());
+//                 bytes.push(0x03);
+//                 // Store the sublist length as big-endian, because readUint16 in solidity
+//                 // does `val = uint16(word >> 240)` (effectively big-endian).
+//                 bytes.extend_from_slice(&sub_len.to_be_bytes());
+//                 // Then the actual sublist payload
+//                 bytes.extend_from_slice(&payload);
+//                 bytes
+//             }
+//         }
+//     }
+// }
+
+
+// #[derive(Debug, Clone, PartialEq)]
+// pub enum SExpr {
+//     Atom(String),          // e.g. "3", "DUP", "+"
+//     List(Vec<SExpr>),      // e.g. (3 5 +)
+// }
+
+// fn tokenize(s: &str) -> Vec<String> {
+//     let mut tokens = Vec::new();
+//     let mut current = String::new();
+
+//     for c in s.chars() {
+//         match c {
+//             '(' | ')' => {
+//                 // If we were building up an atom, push it first
+//                 if !current.trim().is_empty() {
+//                     tokens.push(current.trim().to_string());
+//                 }
+//                 current.clear();
+//                 // Then push the single-char token
+//                 tokens.push(c.to_string());
+//             }
+//             ' ' | '\t' | '\n' | '\r' => {
+//                 // Whitespace => if we have an atom, finish it
+//                 if !current.trim().is_empty() {
+//                     tokens.push(current.trim().to_string());
+//                     current.clear();
+//                 }
+//             }
+//             _ => {
+//                 // Part of an atom
+//                 current.push(c);
+//             }
+//         }
+//     }
+
+//     // If something is left in 'current' at the end
+//     if !current.trim().is_empty() {
+//         tokens.push(current.trim().to_string());
+//     }
+
+//     tokens
+// }
+
+
+// fn parse_sexpr(tokens: &[String], pos: &mut usize) -> Result<SExpr, String> {
+//     // If we’re out of tokens, error
+//     if *pos >= tokens.len() {
+//         return Err("Unexpected end of tokens".into());
+//     }
+
+//     let token = &tokens[*pos];
+//     match token.as_str() {
+//         "(" => {
+//             // Parse a list
+//             *pos += 1; // consume '('
+//             let mut list_items = Vec::new();
+
+//             while *pos < tokens.len() && tokens[*pos] != ")" {
+//                 let expr = parse_sexpr(tokens, pos)?;
+//                 list_items.push(expr);
+//             }
+
+//             if *pos >= tokens.len() {
+//                 return Err("Missing closing parenthesis".into());
+//             }
+//             // consume ")"
+//             *pos += 1;
+//             Ok(SExpr::List(list_items))
+//         }
+//         ")" => {
+//             // Should never parse_sexpr starting with ')'
+//             Err("Unexpected ')'".into())
+//         }
+//         _ => {
+//             // Atom
+//             let atom_str = token.clone();
+//             *pos += 1;
+//             Ok(SExpr::Atom(atom_str))
+//         }
+//     }
+// }
+
+// /// Parse an entire string into a single top-level `SExpr`.
+// fn parse_string_to_sexpr(s: &str) -> Result<SExpr, String> {
+//     let tokens = tokenize(s);
+//     let mut pos = 0;
+//     let expr = parse_sexpr(&tokens, &mut pos)?;
+
+//     // If there's leftover tokens, optionally check
+//     if pos < tokens.len() {
+//         return Err(format!("Extra tokens after parse: {:?}", &tokens[pos..]));
+//     }
+
+//     Ok(expr)
+// }
+
+// fn sexpr_to_untyped(expr: &SExpr) -> Result<UntypedAst, String> {
+//     match expr {
+//         SExpr::Atom(text) => {
+//             // 1) try to parse as i32
+//             if let Ok(val) = text.parse::<i32>() {
+//                 Ok(UntypedAst::IntLiteral(val))
+//             } else {
+//                 // 2) otherwise parse as OpCode symbol
+//                 match text.to_uppercase().as_str() {
+//                     "+" => Ok(UntypedAst::Instruction(OpCode::Plus)),
+//                     "-" => Ok(UntypedAst::Instruction(OpCode::Minus)),
+//                     "*"  => Ok(UntypedAst::Instruction(OpCode::Mult)),
+//                     "DUP" => Ok(UntypedAst::Instruction(OpCode::Dup)),
+//                     "POP" => Ok(UntypedAst::Instruction(OpCode::Pop)),
+//                     // more opcodes ...
+//                     _ => Ok(UntypedAst::Instruction(OpCode::Noop))
+//                 }
+//             }
+//         }
+//         SExpr::List(list) => {
+//             // parse each child into UntypedAst
+//             let mut result = Vec::new();
+//             for child in list {
+//                 result.push(sexpr_to_untyped(child)?);
+//             }
+//             Ok(UntypedAst::Sublist(result))
+//         }
+//     }
+// }
+
+// src/compiler/ast.rs
+
 pub trait Push3Ast {
     /// Convert this AST into a bytecode array (Push3 tokens).
     fn to_bytecode(&self) -> Vec<u8>;
-
-    /// Parse an AST from bytecode (the "decompiler"), if possible.
-    /// Possibly returns a Result in case of partial/invalid parse.
-    fn from_bytecode(data: &[u8]) -> Self
-    where
-        Self: Sized;
-
-    /// Randomly mutate this AST in-place (GP mutation).
-    fn mutate(&mut self, rng: &mut impl rand::Rng);
-
-    /// Possibly a "crossover" method, or we do it externally.
-    // fn crossover(&self, other: &Self, rng: &mut impl rand::Rng) -> Self;
-
-    /// Evaluate the AST with some input(s).
-    /// Optionally do we want this or do we always run in EVM? 
-    /// We can stub it or do an interpret approach for local test.
-    fn interpret_locally(&self, inputs: &[i32]) -> Vec<i32>;
 }
 
+/* --------------------------------------------
+   1) TypedAst stubs (optional)
+-------------------------------------------- */
 
 #[derive(Debug, Clone)]
 pub enum TypedAst {
@@ -32,50 +347,28 @@ pub enum InstructionKind {
     Plus(Box<TypedAst>, Box<TypedAst>),
     Minus(Box<TypedAst>, Box<TypedAst>),
     Mult(Box<TypedAst>, Box<TypedAst>),
-    Dup,  // 0 children
+    Dup,
-    Pop,  // 0 children
+    Pop,
 }
 
+// Example stub; not fully implemented
 impl Push3Ast for TypedAst {
     fn to_bytecode(&self) -> Vec<u8> {
-        // do typed encoding: 
+        unimplemented!("TypedAst::to_bytecode not yet implemented");
-        // - for Plus(e1, e2): e1 -> bytecode, e2 -> bytecode, then PLUS opcode
+    }
-        unimplemented!()
 }
 
-    fn from_bytecode(data: &[u8]) -> Self {
+/* --------------------------------------------
-        // parse in a strictly typed manner; might fail or panic 
+   2) UntypedAst + OpCode
-        // if the code doesn't line up properly
+-------------------------------------------- */
-        unimplemented!()
-    }
-
-    fn mutate(&mut self, rng: &mut impl rand::Rng) {
-        // e.g. randomly pick a node, replace it with something 
-        // that respects the typed structure
-        unimplemented!()
-    }
-
-    fn interpret_locally(&self, inputs: &[i32]) -> Vec<i32> {
-        // do a normal expression evaluation. If a node is "Plus(a,b)",
-        // interpret (a) + interpret(b).
-        unimplemented!()
-    }
-}
 
 #[derive(Debug, Clone)]
 pub enum UntypedAst {
-    /// A single token in a list-based approach, e.g. "Integer literal"
     IntLiteral(i32),
-
-    /// "Instruction" might be a simple variant with no children, 
-    /// because the stack-based evaluation decides how many arguments it consumes.
     Instruction(OpCode),
-
-    /// A sublist of tokens, e.g. "( 2 3 DUP + )"
     Sublist(Vec<UntypedAst>),
 }
 
-/// Possibly an enum for OpCode:
 #[derive(Debug, Clone)]
 pub enum OpCode {
     Noop,
@@ -84,31 +377,154 @@ pub enum OpCode {
     Mult,
     Dup,
     Pop,
-    // maybe Unknown => treat as no-op
 }
 
+/// Implementation of `Push3Ast` for `UntypedAst`.
+/// Matches the Solidity-based Push3Interpreter token IDs.
 impl Push3Ast for UntypedAst {
     fn to_bytecode(&self) -> Vec<u8> {
-        // flatten out sublists vs instructions
+        match self {
-        unimplemented!()
+            UntypedAst::IntLiteral(val) => {
+                // 0x02 => INT_LITERAL => next 4 bytes (little-endian i32)
+                let mut bytes = Vec::with_capacity(1 + 4);
+                bytes.push(0x02);
+                bytes.extend_from_slice(&val.to_be_bytes());
+                bytes
+            }
+            UntypedAst::Instruction(op) => {
+                let opcode_byte = match op {
+                    OpCode::Noop  => 0x00,
+                    OpCode::Plus  => 0x01,
+                    OpCode::Minus => 0x04,
+                    OpCode::Mult  => 0x05,
+                    OpCode::Dup   => 0x06,
+                    OpCode::Pop   => 0x07,
+                };
+                vec![opcode_byte]
+            }
+            UntypedAst::Sublist(children) => {
+                // 0x03 => SUBLIST => next 2 bytes = big-endian length, then sub-payload
+                let mut payload = Vec::new();
+                for child in children {
+                    payload.extend(child.to_bytecode());
+                }
+                let sub_len = payload.len() as u16;
+                let mut bytes = Vec::with_capacity(1 + 2 + payload.len());
+                bytes.push(0x03);
+                bytes.extend_from_slice(&sub_len.to_be_bytes()); // big-endian
+                bytes.extend_from_slice(&payload);
+                bytes
+            }
+        }
+    }
 }
 
-    fn from_bytecode(data: &[u8]) -> Self {
+/* --------------------------------------------
-        // parse "0x02 => INT_LITERAL => read next 4 bytes" 
+   3) S-expression parsing helpers
-        // instructions might have no subchildren
+-------------------------------------------- */
-        unimplemented!()
+#[derive(Debug, Clone, PartialEq)]
+pub enum SExpr {
+    Atom(String),
+    List(Vec<SExpr>),
 }
 
-    fn mutate(&mut self, rng: &mut impl rand::Rng) {
+pub fn tokenize(s: &str) -> Vec<String> {
-        // can randomly insert unknown tokens, reorder sublists, etc.
+    let mut tokens = Vec::new();
-        // possibly produce "invalid ops => noops"
+    let mut current = String::new();
-        unimplemented!()
+
+    for c in s.chars() {
+        match c {
+            '(' | ')' => {
+                if !current.trim().is_empty() {
+                    tokens.push(current.trim().to_string());
+                }
+                current.clear();
+                tokens.push(c.to_string());
+            }
+            ' ' | '\t' | '\n' | '\r' => {
+                if !current.trim().is_empty() {
+                    tokens.push(current.trim().to_string());
+                    current.clear();
+                }
+            }
+            _ => {
+                current.push(c);
+            }
+        }
     }
 
-    fn interpret_locally(&self, inputs: &[i32]) -> Vec<i32> {
+    if !current.trim().is_empty() {
-        // push-based interpretation:
+        tokens.push(current.trim().to_string());
-        // sublist => interpret each item in sequence
+    }
-        // if an instruction sees insufficient args => no-op
+
-        unimplemented!()
+    tokens
+}
+
+fn parse_sexpr_internal(tokens: &[String], pos: &mut usize) -> Result<SExpr, String> {
+    if *pos >= tokens.len() {
+        return Err("Unexpected end of tokens".into());
+    }
+
+    let token = &tokens[*pos];
+    match token.as_str() {
+        "(" => {
+            *pos += 1; // consume '('
+            let mut items = Vec::new();
+            while *pos < tokens.len() && tokens[*pos] != ")" {
+                let expr = parse_sexpr_internal(tokens, pos)?;
+                items.push(expr);
+            }
+            if *pos >= tokens.len() {
+                return Err("Missing closing parenthesis".into());
+            }
+            *pos += 1; // consume ')'
+            Ok(SExpr::List(items))
+        }
+        ")" => {
+            Err("Unexpected ')'".into())
+        }
+        _ => {
+            let atom = token.clone();
+            *pos += 1;
+            Ok(SExpr::Atom(atom))
+        }
+    }
+}
+
+/// Parse an entire string into a single top-level `SExpr`.
+pub fn parse_string_to_sexpr(s: &str) -> Result<SExpr, String> {
+    let tokens = tokenize(s);
+    let mut pos = 0;
+    let expr = parse_sexpr_internal(&tokens, &mut pos)?;
+    if pos < tokens.len() {
+        return Err(format!("Extra tokens after parse: {:?}", &tokens[pos..]));
+    }
+    Ok(expr)
+}
+
+/// Convert an SExpr => UntypedAst
+pub fn sexpr_to_untyped(expr: &SExpr) -> Result<UntypedAst, String> {
+    match expr {
+        SExpr::Atom(text) => {
+            if let Ok(val) = text.parse::<i32>() {
+                Ok(UntypedAst::IntLiteral(val))
+            } else {
+                match text.to_uppercase().as_str() {
+                    "+"   => Ok(UntypedAst::Instruction(OpCode::Plus)),
+                    "-"   => Ok(UntypedAst::Instruction(OpCode::Minus)),
+                    "*"   => Ok(UntypedAst::Instruction(OpCode::Mult)),
+                    "DUP" => Ok(UntypedAst::Instruction(OpCode::Dup)),
+                    "POP" => Ok(UntypedAst::Instruction(OpCode::Pop)),
+                    _     => Ok(UntypedAst::Instruction(OpCode::Noop)),
+                }
+            }
+        }
+        SExpr::List(items) => {
+            let mut sub_asts = Vec::new();
+            for child in items {
+                sub_asts.push(sexpr_to_untyped(child)?);
+            }
+            Ok(UntypedAst::Sublist(sub_asts))
+        }
     }
 }

offchain/src/evm_integration/revm_runner.rs

@@ -1,5 +0,0 @@
-pub fn run_in_revm(bytecode: &[u8]) -> Result<Vec<i64>, String> {
-    // set up revm, load the code, call push3
-    // for now just stub
-    Ok(vec![])
-}