CLI: charms spell check

Add `charms spell check` command to perform the same checks that `charms spell prove` does (when proving a spell), but much faster.

Author: imikushin

charms-spell-checker/src/app.rs

@@ -1,6 +1,4 @@
-use charms_data::{
-    nft_state_preserved, token_amounts_balanced, util, App, Data, Transaction, NFT, TOKEN,
-};
+use charms_data::{is_simple_transfer, util, App, Data, Transaction};
 use serde::{Deserialize, Serialize};
 use sp1_primitives::io::SP1PublicValues;
 use sp1_zkvm::lib::verify::verify_sp1_proof;
@@ -28,11 +26,7 @@ impl AppContractVK {
                 verify_sp1_proof(vk, &pv);
                 true
             }
-            None => match app.tag {
-                TOKEN => token_amounts_balanced(app, &tx),
-                NFT => nft_state_preserved(app, &tx),
-                _ => false,
-            },
+            None => is_simple_transfer(app, tx),
         }
     }
 }

src/app.rs

@@ -1,5 +1,5 @@
 use anyhow::ensure;
-use charms_data::{util, App, Data, Transaction, B32};
+use charms_data::{is_simple_transfer, util, App, Data, Transaction, B32};
 use sp1_prover::components::CpuProverComponents;
 use sp1_sdk::{HashableKey, ProverClient, SP1Proof, SP1ProofMode, SP1Stdin, SP1VerifyingKey};
 use std::{collections::BTreeMap, mem};
@@ -50,6 +50,7 @@ impl Prover {
                 eprintln!("app binary not present: {:?}", app);
                 continue;
             };
+            dbg!(app);
             let mut app_stdin = SP1Stdin::new();
             let empty = Data::empty();
             let w = app_private_inputs.get(app).unwrap_or(&empty);
@@ -61,14 +62,48 @@ impl Prover {
             let SP1Proof::Compressed(compressed_proof) = app_proof.proof else {
                 unreachable!()
             };
-            dbg!(app);
-            eprintln!("app proof generated!");
+            eprintln!("app proof generated! for {:?}", app);
             spell_stdin.write_proof(*compressed_proof, vk.vk.clone());
         }
 
         Ok(())
     }
 
+    pub(crate) fn run_all(
+        &self,
+        app_binaries: &BTreeMap<B32, Vec<u8>>,
+        tx: &Transaction,
+        app_public_inputs: &BTreeMap<App, Data>,
+        app_private_inputs: BTreeMap<App, Data>,
+    ) -> anyhow::Result<()> {
+        for (app, x) in app_public_inputs {
+            let mut app_stdin = SP1Stdin::new();
+            let empty = Data::empty();
+            let w = app_private_inputs.get(app).unwrap_or(&empty);
+            app_stdin.write_vec(util::write(&(app, tx, x, w))?);
+            match app_binaries.get(&app.vk) {
+                Some(app_binary) => {
+                    let (committed_values, _report) =
+                        self.client.execute(app_binary, &app_stdin)?;
+
+                    let com: (App, Transaction, Data) =
+                        util::read(committed_values.to_vec().as_slice())?;
+                    ensure!(
+                        (&com.0, &com.1, &com.2) == (app, tx, x),
+                        "committed data mismatch"
+                    );
+                }
+                None => ensure!(is_simple_transfer(app, tx)),
+            }
+
+            dbg!(app);
+
+            eprintln!("app checked!");
+        }
+
+        Ok(())
+    }
+
     pub fn run(
         &self,
         app_binary: &[u8],

src/cli/app.rs

@@ -1,4 +1,4 @@
-use crate::{app, spell::Spell};
+use crate::{app, app::Prover, spell::Spell};
 use anyhow::{anyhow, ensure, Result};
 use charms_data::{Data, B32};
 use std::{
@@ -136,3 +136,18 @@ fn data_for_key(inputs: &BTreeMap<String, Data>, k: &String) -> Data {
         None => Data::empty(),
     }
 }
+
+pub fn binaries_by_vk(
+    app_prover: &Prover,
+    app_bins: Vec<PathBuf>,
+) -> Result<BTreeMap<B32, Vec<u8>>> {
+    let binaries: BTreeMap<B32, Vec<u8>> = app_bins
+        .iter()
+        .map(|path| {
+            let binary = std::fs::read(path)?;
+            let vk_hash = app_prover.vk(&binary);
+            Ok((B32(vk_hash), binary))
+        })
+        .collect::<Result<_>>()?;
+    Ok(binaries)
+}

src/cli/mod.rs

@@ -116,9 +116,21 @@ pub struct SpellProveParams {
     fee_rate: f64,
 }
 
+#[derive(Args)]
+pub struct SpellCheckParams {
+    /// Path to spell source file (YAML/JSON).
+    #[arg(long, default_value = "/dev/stdin")]
+    spell: PathBuf,
+    /// Path to the apps' RISC-V binaries.
+    #[arg(long, value_delimiter = ',')]
+    app_bins: Vec<PathBuf>,
+}
+
 #[derive(Subcommand)]
 pub enum SpellCommands {
-    /// Prove a spell.
+    /// Check the spell is correct.
+    Check(#[command(flatten)] SpellCheckParams),
+    /// Prove the spell is correct.
     Prove(#[command(flatten)] SpellProveParams),
 }
 
@@ -204,6 +216,7 @@ pub async fn run() -> anyhow::Result<()> {
     match cli.command {
         Commands::Server(server_config) => server::server(server_config).await,
         Commands::Spell { command } => match command {
+            SpellCommands::Check(params) => spell::check(params),
             SpellCommands::Prove(params) => spell::prove(params),
         },
         Commands::Tx { command } => match command {

src/cli/spell.rs

@@ -1,4 +1,12 @@
-use crate::{cli::SpellProveParams, spell, spell::Spell, tx, tx::txs_by_txid, utils};
+use crate::{
+    app, cli,
+    cli::{SpellCheckParams, SpellProveParams},
+    spell,
+    spell::Spell,
+    tx,
+    tx::txs_by_txid,
+    utils, SPELL_VK,
+};
 use anyhow::{ensure, Result};
 use bitcoin::{
     consensus::encode::{deserialize_hex, serialize_hex},
@@ -20,7 +28,7 @@ pub fn prove(
     utils::logger::setup_logger();
 
     // Parse funding UTXO early: to fail fast
-    let funding_utxo = crate::cli::tx::parse_outpoint(&funding_utxo_id)?;
+    let funding_utxo = cli::tx::parse_outpoint(&funding_utxo_id)?;
 
     ensure!(fee_rate >= 1.0, "fee rate must be >= 1.0");
 
@@ -30,16 +38,23 @@ pub fn prove(
         Some(tx) => deserialize_hex::<Transaction>(&tx)?,
         None => tx::from_spell(&spell),
     };
+    let prev_txs = prev_txs
+        .into_iter()
+        .map(|tx| Ok(deserialize_hex::<Transaction>(&tx)?))
+        .collect::<Result<_>>()?;
     let prev_txs = txs_by_txid(prev_txs)?;
     ensure!(tx
         .input
         .iter()
         .all(|input| prev_txs.contains_key(&input.previous_output.txid)));
 
+    let app_prover = app::Prover::new();
+    let binaries = cli::app::binaries_by_vk(&app_prover, app_bins)?;
+
     let transactions = spell::prove_spell_tx(
         spell,
         tx,
-        app_bins,
+        binaries,
         prev_txs,
         funding_utxo,
         funding_utxo_value,
@@ -55,3 +70,52 @@ pub fn prove(
 
     Ok(())
 }
+
+pub fn check(SpellCheckParams { spell, app_bins }: SpellCheckParams) -> Result<()> {
+    utils::logger::setup_logger();
+
+    let mut spell: Spell = serde_yaml::from_slice(&std::fs::read(spell)?)?;
+    for u in spell.outs.iter_mut() {
+        u.sats.get_or_insert(crate::cli::wallet::MIN_SATS);
+    }
+
+    // make sure spell inputs all have utxo_id
+    ensure!(
+        spell.ins.iter().all(|u| u.utxo_id.is_some()),
+        "all spell inputs must have utxo_id"
+    );
+
+    let tx = tx::from_spell(&spell);
+
+    let prev_txs = cli::tx::get_prev_txs(&tx)?;
+
+    eprintln!("checking prev_txs");
+    let prev_spells = charms_client::prev_spells(&prev_txs, &SPELL_VK);
+    eprintln!("checking prev_txs... done!");
+
+    let (norm_spell, app_private_inputs) = spell.normalized()?;
+    let norm_spell = spell::align_spell_to_tx(norm_spell, &tx)?;
+
+    eprintln!("checking spell is well-formed");
+    ensure!(
+        charms_client::well_formed(&norm_spell, &prev_spells),
+        "spell is not well-formed"
+    );
+    eprintln!("checking spell is well-formed... done!");
+
+    eprintln!("checking spell is correct");
+    let app_prover = app::Prover::new();
+
+    let binaries = cli::app::binaries_by_vk(&app_prover, app_bins)?;
+
+    let charms_tx = spell.to_tx()?;
+    app_prover.run_all(
+        &binaries,
+        &charms_tx,
+        &norm_spell.app_public_inputs,
+        app_private_inputs,
+    )?;
+    eprintln!("checking spell is correct... done!");
+
+    Ok(())
+}

src/cli/tx.rs

@@ -1,6 +1,10 @@
 use crate::{cli, tx};
 use anyhow::{anyhow, Result};
-use bitcoin::{consensus::encode::deserialize_hex, OutPoint, Transaction};
+use bitcoin::{
+    consensus::encode::{deserialize_hex, serialize_hex},
+    OutPoint, Transaction,
+};
+use std::process::Command;
 
 pub(crate) fn parse_outpoint(s: &str) -> Result<OutPoint> {
     let parts: Vec<&str> = s.split(':').collect();
@@ -21,3 +25,15 @@ pub fn tx_show_spell(tx: String, json: bool) -> Result<()> {
 
     Ok(())
 }
+
+pub(crate) fn get_prev_txs(tx: &Transaction) -> Result<Vec<Transaction>> {
+    let cmd_output = Command::new("bash")
+        .args(&[
+            "-c", format!("bitcoin-cli decoderawtransaction {} | jq -r '.vin[].txid' | sort | uniq | xargs -I {{}} bitcoin-cli getrawtransaction {{}} | paste -sd, -", serialize_hex(tx)).as_str()
+        ])
+        .output()?;
+    String::from_utf8(cmd_output.stdout)?
+        .split(',')
+        .map(|s| Ok(deserialize_hex::<Transaction>(s.trim())?))
+        .collect()
+}

src/cli/wallet.rs

@@ -1,5 +1,5 @@
 use crate::{
-    cli,
+    app, cli,
     cli::{WalletCastParams, WalletListParams},
     spell::{prove_spell_tx, KeyedCharms, Spell},
     tx,
@@ -181,7 +181,7 @@ fn get_tx(txid: &str) -> Result<Transaction> {
     Ok(tx)
 }
 
-const MIN_SATS: u64 = 1000;
+pub const MIN_SATS: u64 = 1000;
 
 pub fn cast(
     WalletCastParams {
@@ -217,14 +217,17 @@ pub fn cast(
 
     let tx = tx::from_spell(&spell);
 
-    let prev_txs = txs_by_txid(get_prev_txs(&tx)?)?;
+    let prev_txs = txs_by_txid(cli::tx::get_prev_txs(&tx)?)?;
     let funding_utxo_value = funding_utxo_value(&funding_utxo)?;
     let change_address = new_change_address()?;
 
+    let app_prover = app::Prover::new();
+    let binaries = cli::app::binaries_by_vk(&app_prover, app_bins)?;
+
     let [commit_tx, spell_tx] = prove_spell_tx(
         spell,
         tx,
-        app_bins,
+        binaries,
         prev_txs,
         funding_utxo,
         funding_utxo_value,
@@ -287,15 +290,3 @@ fn funding_utxo_value(utxo: &OutPoint) -> Result<u64> {
     let cmd_out = Command::new("bash").args(&["-c", &cmd]).output()?;
     Ok(String::from_utf8(cmd_out.stdout)?.trim().parse()?)
 }
-
-fn get_prev_txs(tx: &Transaction) -> Result<Vec<String>> {
-    let cmd_output = Command::new("bash")
-        .args(&[
-            "-c", format!("bitcoin-cli decoderawtransaction {} | jq -r '.vin[].txid' | sort | uniq | xargs -I {{}} bitcoin-cli getrawtransaction {{}} | paste -sd, -", serialize_hex(tx)).as_str()
-        ])
-        .output()?;
-    Ok(String::from_utf8(cmd_output.stdout)?
-        .split(',')
-        .map(|s| s.trim().to_string())
-        .collect())
-}

src/spell.rs

@@ -10,7 +10,6 @@ use serde::{Deserialize, Serialize};
 use sp1_sdk::{HashableKey, ProverClient, SP1Stdin};
 use std::{
     collections::{BTreeMap, BTreeSet},
-    path::PathBuf,
     str::FromStr,
 };
 
@@ -366,26 +365,15 @@ $TOAD: 9
 pub fn prove_spell_tx(
     spell: Spell,
     tx: bitcoin::Transaction,
-    app_bins: Vec<PathBuf>,
+    binaries: BTreeMap<B32, Vec<u8>>,
     prev_txs: BTreeMap<Txid, bitcoin::Transaction>,
     funding_utxo: OutPoint,
     funding_utxo_value: u64,
     change_address: String,
     fee_rate: f64,
 ) -> anyhow::Result<[bitcoin::Transaction; 2]> {
-    let (mut norm_spell, app_private_inputs) = spell.normalized()?;
-    align_spell_to_tx(&mut norm_spell, &tx)?;
-
-    let app_prover = app::Prover::new();
-
-    let binaries = app_bins
-        .iter()
-        .map(|path| {
-            let binary = std::fs::read(path)?;
-            let vk_hash = app_prover.vk(&binary);
-            Ok((B32(vk_hash), binary))
-        })
-        .collect::<anyhow::Result<_>>()?;
+    let (norm_spell, app_private_inputs) = spell.normalized()?;
+    let norm_spell = align_spell_to_tx(norm_spell, &tx)?;
 
     let (norm_spell, proof) = prove(
         norm_spell,
@@ -418,10 +406,11 @@ pub fn prove_spell_tx(
     Ok(transactions)
 }
 
-fn align_spell_to_tx(
-    norm_spell: &mut NormalizedSpell,
+pub(crate) fn align_spell_to_tx(
+    norm_spell: NormalizedSpell,
     tx: &bitcoin::Transaction,
-) -> anyhow::Result<()> {
+) -> anyhow::Result<NormalizedSpell> {
+    let mut norm_spell = norm_spell;
     let spell_ins = norm_spell.tx.ins.as_ref().ok_or(anyhow!("no inputs"))?;
 
     ensure!(
@@ -458,5 +447,5 @@ fn align_spell_to_tx(
         norm_spell.tx.ins.get_or_insert_with(Vec::new).push(utxo_id);
     }
 
-    Ok(())
+    Ok(norm_spell)
 }