Merge pull request #3 from Chia-Network/20240505-build-rs

introduce build.rs and ci integration

Author: prozacchiwawa

.github/workflows/build-test.yml

@@ -110,14 +110,10 @@ jobs:
           export RUSTFLAGS="-Cinstrument-coverage"
           export LLVM_PROFILE_FILE=$(pwd)/target/clvm_tools_rs-%p-%m.profraw
           export CARGO_TARGET_DIR=$(pwd)/target
-          cargo test --release --workspace
           python -m venv venv
           source venv/bin/activate
-          git clone https://github.com/Chia-Network/clvm_tools.git --branch=main --single-branch
-          pip install ./clvm_tools
-          pip install maturin pytest
-          maturin develop --release
-          (cd resources/tests/cmdline/tests && pytest)
+          pip install chia-blockchain
+          cargo test --release --workspace --features=sim-tests
           grcov . --binary-path target -s . --branch --ignore-not-existing --ignore='*/.cargo/*' --ignore='*/tests/*' -o rust_cov.info
           python -c 'with open("rust_cov.info") as f: lines = [l for l in f if not (l.startswith("DA:") and int(l.split(",")[1].strip()) >= 2**63)]; open("lcov.info", "w").writelines(lines)'
       - name: Upload to Coveralls

Cargo.toml

@@ -7,15 +7,15 @@ edition = "2021"
 sim-tests = []
 
 [dependencies]
-clvm_tools_rs = "0.1.42"
-clvmr = { version = "0.3.0", features = ["pre-eval"] }
+clvm_tools_rs = { git = "https://github.com/Chia-Network/clvm_tools_rs.git", rev = "ec75759377791c9b785123d2d3e2457d08ac6621" }
+clvmr = { version = "=0.3.2", features = ["pre-eval"] }
 serde_json = "1.0"
 rand = "0.8.5"
 rand_chacha = "0.3.1"
 clvm-traits = "0.7.0"
 subtle = "2.5.0"
 num-bigint = "0.4.4"
-num-traits = "0.2.18"
+num-traits = "0.2.15"
 chia-bls = "0.7.0"
 clvm-utils = "0.7.0"
 lazy_static = "1.4.0"
@@ -32,9 +32,14 @@ tracing-subscriber = "0.3"
 
 [dev-dependencies]
 pyo3 = { version = "0.20.0", features = ["auto-initialize"] }
-
 bls12_381 = { version = "=0.8.0", features = ["experimental"] }
 
+[build-dependencies]
+serde = "1.0.203"
+toml = "0.8.14"
+clvm_tools_rs = { git = "https://github.com/Chia-Network/clvm_tools_rs.git", rev = "ec75759377791c9b785123d2d3e2457d08ac6621" }
+clvmr = { version = "=0.3.2", features = ["pre-eval"] }
+
 [lib]
 name = "chia_gaming"
 crate-type = ["cdylib", "rlib"]

build.rs

@@ -0,0 +1,75 @@
+use std::collections::HashMap;
+use std::fs;
+
+use clvmr::Allocator;
+use toml::{Table, Value};
+
+use clvm_tools_rs::classic::clvm_tools::clvmc::CompileError;
+use clvm_tools_rs::classic::clvm_tools::comp_input::RunAndCompileInputData;
+use clvm_tools_rs::classic::platform::argparse::ArgumentValue;
+use clvm_tools_rs::compiler::comptypes::CompileErr;
+use clvm_tools_rs::compiler::srcloc::Srcloc;
+
+fn do_compile(title: &str, filename: &str) -> Result<(), CompileError> {
+    let mut allocator = Allocator::new();
+    let mut arguments: HashMap<String, ArgumentValue> = HashMap::new();
+    arguments.insert(
+        "include".to_string(),
+        ArgumentValue::ArgArray(vec![ArgumentValue::ArgString(None, ".".to_string())]),
+    );
+
+    let file_content = fs::read_to_string(filename).map_err(|e| {
+        CompileErr(
+            Srcloc::start(filename),
+            format!("failed to read {filename}: {e:?}"),
+        )
+    })?;
+
+    arguments.insert(
+        "path_or_code".to_string(),
+        ArgumentValue::ArgString(Some(filename.to_string()), file_content),
+    );
+
+    let parsed = RunAndCompileInputData::new(&mut allocator, &arguments).map_err(|e| {
+        CompileError::Modern(
+            Srcloc::start("*error*"),
+            format!("error building chialisp {title}: {e}"),
+        )
+    })?;
+    let mut symbol_table = HashMap::new();
+
+    parsed.compile_modern(&mut allocator, &mut symbol_table)?;
+
+    Ok(())
+}
+
+fn compile_chialisp() -> Result<(), CompileError> {
+    let srcloc = Srcloc::start("chialisp.toml");
+    let chialisp_toml_text = fs::read_to_string("chialisp.toml").map_err(|e| {
+        CompileError::Modern(
+            srcloc.clone(),
+            format!("Error reading chialisp.toml: {e:?}"),
+        )
+    })?;
+
+    let chialisp_toml = chialisp_toml_text
+        .parse::<Table>()
+        .map_err(|e| CompileError::Modern(srcloc, format!("Error parsing chialisp.toml: {e:?}")))?;
+
+    if let Some(Value::Table(t)) = chialisp_toml.get("compile") {
+        for (k, v) in t.iter() {
+            if let Value::String(s) = v {
+                do_compile(k, s)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// Compile chialisp programs in this tree.
+fn main() {
+    if let Err(e) = compile_chialisp() {
+        panic!("error compiling chialisp: {e:?}");
+    }
+}

chialisp.toml

@@ -0,0 +1,3 @@
+[compile]
+unroll-puzzle = "resources/unroll_puzzle.clsp"
+unroll-meta-puzzle = "resources/unroll_meta_puzzle.clsp"

src/channel_handler/game.rs

@@ -1,6 +1,5 @@
 use clvm_traits::{ClvmEncoder, ToClvm};
-use clvmr::allocator::NodePtr;
-use clvmr::run_program;
+use clvmr::{run_program, NodePtr};
 
 use clvm_tools_rs::classic::clvm::sexp::proper_list;
 
@@ -66,11 +65,11 @@ impl Game {
             .expect("should be an atom");
         let required_size_factor = Amount::new(
             atom_from_clvm(allocator, template_list[3])
-                .and_then(|a| u64_from_atom(a))
+                .and_then(u64_from_atom)
                 .expect("should be an atom"),
         );
         let initial_max_move_size = atom_from_clvm(allocator, template_list[4])
-            .and_then(|a| usize_from_atom(a))
+            .and_then(usize_from_atom)
             .expect("should be an atom");
         let initial_validation_program = ValidationProgram::new(allocator, template_list[5]);
         let initial_validation_program_hash =
@@ -83,7 +82,7 @@ impl Game {
             };
         let initial_state = template_list[7];
         let initial_mover_share_proportion = atom_from_clvm(allocator, template_list[8])
-            .and_then(|a| usize_from_atom(a))
+            .and_then(usize_from_atom)
             .expect("should be an atom");
         Ok(Game {
             id: game_id,

src/channel_handler/game_handler.rs

@@ -155,7 +155,7 @@ fn run_code(
 pub enum TheirTurnResult {
     FinalMove(NodePtr),
     MakeMove(NodePtr, GameHandler, Vec<u8>),
-    Slash(Evidence, Aggsig),
+    Slash(Evidence, Box<Aggsig>),
 }
 
 impl GameHandler {
@@ -206,10 +206,7 @@ impl GameHandler {
                 inputs.amount.clone(),
                 (
                     inputs.last_mover_share.clone(),
-                    (
-                        inputs.last_max_move_size.clone(),
-                        (inputs.entropy.clone(), ()),
-                    ),
+                    (inputs.last_max_move_size, (inputs.entropy.clone(), ())),
                 ),
             ),
         )
@@ -249,27 +246,27 @@ impl GameHandler {
         }
 
         let max_move_size =
-            if let Some(mm) = atom_from_clvm(allocator, pl[4]).and_then(|a| usize_from_atom(a)) {
+            if let Some(mm) = atom_from_clvm(allocator, pl[4]).and_then(usize_from_atom) {
                 mm
             } else {
                 return Err(Error::StrErr("bad max move size".to_string()));
             };
-        let mover_share =
-            if let Some(ms) = atom_from_clvm(allocator, pl[5]).and_then(|a| u64_from_atom(a)) {
-                Amount::new(ms)
-            } else {
-                return Err(Error::StrErr(format!(
-                    "bad share {}",
-                    disassemble(allocator.allocator(), pl[5], None)
-                )));
-            };
+        let mover_share = if let Some(ms) = atom_from_clvm(allocator, pl[5]).and_then(u64_from_atom)
+        {
+            Amount::new(ms)
+        } else {
+            return Err(Error::StrErr(format!(
+                "bad share {}",
+                disassemble(allocator.allocator(), pl[5], None)
+            )));
+        };
         let message_parser = if pl[7] == allocator.allocator().null() {
             None
         } else {
             Some(MessageHandler::from_nodeptr(pl[7]))
         };
         let validation_program_hash =
-            if let Some(h) = atom_from_clvm(allocator, pl[2]).map(|a| Hash::from_slice(a)) {
+            if let Some(h) = atom_from_clvm(allocator, pl[2]).map(Hash::from_slice) {
                 h
             } else {
                 return Err(Error::StrErr("bad hash".to_string()));
@@ -312,7 +309,7 @@ impl GameHandler {
         let driver_args = (
             inputs.amount.clone(),
             (
-                Node(inputs.last_state.clone()),
+                Node(inputs.last_state),
                 (
                     Node(
                         allocator
@@ -322,7 +319,7 @@ impl GameHandler {
                     (
                         inputs.new_move.validation_info_hash.clone(),
                         (
-                            inputs.new_move.basic.max_move_size.clone(),
+                            inputs.new_move.basic.max_move_size,
                             (inputs.new_move.basic.mover_share.clone(), ()),
                         ),
                     ),
@@ -362,10 +359,10 @@ impl GameHandler {
 
         if move_type == 0 {
             if pl.len() < 2 {
-                return Err(Error::StrErr(format!(
+                Err(Error::StrErr(format!(
                     "bad length for move result {}",
                     disassemble(allocator.allocator(), run_result, None)
-                )));
+                )))
             } else if pl.len() < 3 {
                 Ok(TheirTurnResult::FinalMove(pl[1]))
             } else {
@@ -390,7 +387,7 @@ impl GameHandler {
             let sig_bytes = allocator.allocator().atom(pl[2]).to_vec();
             Ok(TheirTurnResult::Slash(
                 Evidence::from_nodeptr(pl[1]),
-                Aggsig::from_slice(&sig_bytes)?,
+                Box::new(Aggsig::from_slice(&sig_bytes)?),
             ))
         } else {
             Err(Error::StrErr("unknown move result type".to_string()))