Merge pull request #178 from xch-dev/compiler-bindings

Add IR and compiler CLVM bindings

Cargo.toml

@@ -162,6 +162,7 @@ sha2 = "0.10.8"
 pyo3 = "0.23.3"
 js-sys = "0.3.77"
 parking_lot = "0.12.3"
+clvm_tools_rs = "0.1.46"
 
 [profile.release]
 lto = true

bindings/clvm.json

@@ -19,6 +19,12 @@
       "coin_spends": {
         "return": "Vec<CoinSpend>"
       },
+      "parse": {
+        "args": {
+          "program": "String"
+        },
+        "return": "Program"
+      },
       "deserialize": {
         "args": {
           "value": "SerializedProgram"

bindings/program.json

@@ -2,6 +2,12 @@
   "Program": {
     "type": "class",
     "methods": {
+      "compile": {
+        "return": "Output"
+      },
+      "unparse": {
+        "return": "String"
+      },
       "serialize": {
         "return": "SerializedProgram"
       },

crates/chia-sdk-bindings/Cargo.toml

@@ -40,3 +40,4 @@ rand = { workspace = true }
 rand_chacha = { workspace = true }
 num-bigint = { workspace = true }
 paste = { workspace = true }
+clvm_tools_rs = { workspace = true }

crates/chia-sdk-bindings/src/clvm.rs

@@ -4,6 +4,7 @@ use bindy::{Error, Result};
 use chia_protocol::{Bytes, Bytes32, Program as SerializedProgram};
 use chia_puzzle_types::nft;
 use chia_sdk_driver::{HashedPtr, Launcher, SpendContext, StandardLayer};
+use clvm_tools_rs::classic::clvm_tools::binutils::assemble;
 use clvm_traits::{clvm_quote, ToClvm};
 use clvm_utils::TreeHash;
 use clvmr::{
@@ -207,6 +208,12 @@ impl Clvm {
         })
     }
 
+    pub fn parse(&self, program: String) -> Result<Program> {
+        let mut ctx = self.0.write().unwrap();
+        let ptr = assemble(&mut ctx.allocator, &program)?;
+        Ok(Program(self.0.clone(), ptr))
+    }
+
     pub fn deserialize(&self, value: SerializedProgram) -> Result<Program> {
         let mut ctx = self.0.write().unwrap();
         let ptr = node_from_bytes(&mut ctx.allocator, &value)?;

crates/chia-sdk-bindings/src/program.rs

@@ -4,6 +4,11 @@ use bindy::{Error, Result};
 use chia_protocol::{Bytes, Program as SerializedProgram};
 use chia_puzzle_types::nft;
 use chia_sdk_driver::SpendContext;
+use clvm_tools_rs::classic::clvm_tools::stages::run;
+use clvm_tools_rs::classic::clvm_tools::stages::stage_0::TRunProgram;
+use clvm_tools_rs::classic::clvm_tools::{
+    binutils::disassemble, stages::stage_2::operators::run_program_for_search_paths,
+};
 use clvm_traits::{ClvmDecoder, ClvmEncoder, FromClvm};
 use clvm_utils::{tree_hash, TreeHash};
 use clvmr::{
@@ -19,6 +24,25 @@ use crate::{CurriedProgram, NftMetadata, Output, Pair, Puzzle};
 pub struct Program(pub(crate) Arc<RwLock<SpendContext>>, pub(crate) NodePtr);
 
 impl Program {
+    pub fn compile(&self) -> Result<Output> {
+        let mut ctx = self.0.write().unwrap();
+
+        let invoke = run(&mut ctx.allocator);
+        let input = ctx.allocator.new_pair(self.1, NodePtr::NIL)?;
+        let run_program = run_program_for_search_paths("program.clsp", &[], false);
+        let output = run_program.run_program(&mut ctx.allocator, invoke, input, None)?;
+
+        Ok(Output {
+            value: Program(self.0.clone(), output.1),
+            cost: output.0,
+        })
+    }
+
+    pub fn unparse(&self) -> Result<String> {
+        let ctx = self.0.read().unwrap();
+        Ok(disassemble(&ctx.allocator, self.1, None))
+    }
+
     pub fn serialize(&self) -> Result<SerializedProgram> {
         let ctx = self.0.read().unwrap();
         Ok(node_to_bytes(&ctx.allocator, self.1)?.into())

napi/index.d.ts

@@ -446,6 +446,8 @@ export declare class Mnemonic {
   toSeed(password: string): Uint8Array
 }
 export declare class Program {
+  compile(): Output
+  unparse(): string
   serialize(): Uint8Array
   serializeWithBackrefs(): Uint8Array
   run(solution: Program, maxCost: bigint, mempoolMode: boolean): Output
@@ -588,6 +590,7 @@ export declare class Clvm {
   addCoinSpend(coinSpend: CoinSpend): void
   spendCoin(coin: Coin, spend: Spend): void
   coinSpends(): Array<CoinSpend>
+  parse(program: string): Program
   deserialize(value: Uint8Array): Program
   deserializeWithBackrefs(value: Uint8Array): Program
   pair(first: Program, rest: Program): Program