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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use essential_constraint_vm as constraint_vm;
use essential_debugger::Source;
use essential_sign::secp256k1::{PublicKey, Secp256k1, SecretKey};
use essential_state_read_vm as state_read_vm;
use essential_types::{
    predicate::{Directive, Predicate},
    solution::{Mutation, Solution, SolutionData},
    PredicateAddress,
};

#[tokio::test]
#[ignore = "can't run in ci"]
async fn test_debugger() {
    let predicate = Predicate {
        // State read program to read state slot 0.
        state_read: vec![state_read_vm::asm::to_bytes([
            state_read_vm::asm::Stack::Push(1).into(),
            state_read_vm::asm::StateSlots::AllocSlots.into(),
            state_read_vm::asm::Stack::Push(0).into(),
            state_read_vm::asm::Stack::Push(0).into(),
            state_read_vm::asm::Stack::Push(0).into(),
            state_read_vm::asm::Stack::Push(0).into(),
            state_read_vm::asm::Stack::Push(4).into(),
            state_read_vm::asm::Stack::Push(1).into(),
            state_read_vm::asm::Stack::Push(0).into(),
            state_read_vm::asm::StateRead::KeyRange,
            state_read_vm::asm::TotalControlFlow::Halt.into(),
        ])
        .collect()],
        // Program to check pre-mutation value is None and
        // post-mutation value is 42 at slot 0.
        constraints: vec![constraint_vm::asm::to_bytes([
            constraint_vm::asm::Stack::Push(0).into(),
            constraint_vm::asm::Stack::Push(1).into(),
            constraint_vm::asm::Stack::Push(2).into(),
            constraint_vm::asm::Stack::Push(3).into(),
            constraint_vm::asm::Stack::Pop.into(),
            constraint_vm::asm::Stack::Pop.into(),
            constraint_vm::asm::Stack::Pop.into(),
            constraint_vm::asm::Stack::Pop.into(),
            constraint_vm::asm::Stack::Push(0).into(), // slot
            constraint_vm::asm::Stack::Push(0).into(), // pre
            constraint_vm::asm::Access::StateLen.into(),
            constraint_vm::asm::Stack::Push(0).into(),
            constraint_vm::asm::Pred::Eq.into(),
            constraint_vm::asm::Stack::Push(0).into(), // slot
            constraint_vm::asm::Stack::Push(1).into(), // post
            constraint_vm::asm::Access::State.into(),
            constraint_vm::asm::Stack::Push(42).into(),
            constraint_vm::asm::Pred::Eq.into(),
            constraint_vm::asm::Pred::And.into(),
        ])
        .collect()],
        directive: Directive::Satisfy,
    };

    let (sk, _pk) = random_keypair([0; 32]);
    let contract = essential_sign::contract::sign(vec![predicate.clone()].into(), &sk);
    let predicate_addr = PredicateAddress {
        contract: essential_hash::contract_addr::from_contract(&contract.contract),
        predicate: essential_hash::content_addr(&contract.contract.predicates[0]),
    };

    // Construct the solution decision variables.
    // The first is an inline variable 42.
    let decision_variables = vec![vec![42]];

    // Create the solution.
    let solution = Solution {
        data: vec![SolutionData {
            predicate_to_solve: predicate_addr,
            decision_variables,
            state_mutations: vec![Mutation {
                key: vec![0, 0, 0, 0],
                value: vec![42],
            }],
            transient_data: vec![],
        }],
    };

    let other_source = r#"
const ::foo::FOO: int = 1;
    "#;
    let predicate_source = r#"
predicate ::Foo {
    storage {
        bar: ( b256 => int ),
    }
    pub var ::baz: int;
    constraint (::baz == 42);
    constraint (::baz == 1);
}
    "#;

    let source = Source::default()
        .with_other_code(other_source)
        .with_predicate_find_line(predicate_source, 1);

    essential_debugger::run_with_source(solution, 0, predicate, 0, Default::default(), source)
        .await
        .unwrap();
}

pub fn random_keypair(seed: [u8; 32]) -> (SecretKey, PublicKey) {
    use rand::SeedableRng;
    let mut rng = rand::rngs::SmallRng::from_seed(seed);
    let secp = Secp256k1::new();
    secp.generate_keypair(&mut rng)
}