essential-debugger 0.2.0

An experimental constraint debugger for the Essential constraint checking engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use std::path::PathBuf;

use clap::{Parser, Subcommand};
use essential_types::{
    contract::{Contract, SignedContract},
    predicate::Predicate,
    solution::Solution,
};

#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    /// Which solution data index to debug
    #[arg(short, long, default_value_t = 0)]
    solution_data_index: usize,
    /// Which predicate to debug
    #[arg(short, long, default_value_t = 0)]
    predicate_index: usize,
    /// Which constraint to debug
    #[arg(short, long, default_value_t = 0)]
    constraint_index: usize,
    /// Path to the solution file encoded in JSON
    solution: PathBuf,
    /// Select a subcommand to run
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    Predicate {
        /// Path to the individual predicate file encoded in JSON
        predicate: PathBuf,
    },
    Contract {
        /// Path to a contract file encoded in JSON
        contract: PathBuf,
    },
    SignedContract {
        /// Path to a signed contract file encoded in JSON
        contract: PathBuf,
    },
}

#[tokio::main]
async fn main() {
    let args = Cli::parse();
    if let Err(e) = run(args).await {
        eprintln!("Command failed because: {}", e);
    }
}

async fn run(args: Cli) -> anyhow::Result<()> {
    // TODO state.
    let Cli {
        solution_data_index,
        predicate_index,
        constraint_index,
        solution,
        command,
    } = args;
    let predicates: Vec<Predicate> = match command {
        Command::Predicate { predicate } => {
            vec![serde_json::from_slice(&tokio::fs::read(predicate).await?)?]
        }
        Command::Contract { contract } => {
            let contract: Contract = serde_json::from_slice(&tokio::fs::read(contract).await?)?;
            contract.predicates
        }
        Command::SignedContract { contract } => {
            let contract: SignedContract =
                serde_json::from_slice(&tokio::fs::read(contract).await?)?;
            contract.contract.predicates
        }
    };

    let solution: Solution = serde_json::from_slice(&tokio::fs::read(solution).await?)?;
    let predicate = predicates
        .get(predicate_index)
        .ok_or_else(|| anyhow::anyhow!("Predicate not found"))?
        .clone();
    essential_debugger::run(
        solution,
        solution_data_index as u16,
        predicate,
        constraint_index,
        Default::default(),
    )
    .await
}