essential-server 0.4.0

Declaritive 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

use essential_types::{
    contract::Contract,
    predicate::Predicate,
    solution::{Mutation, Solution, SolutionData},
    ContentAddress, PredicateAddress,
};

/// # Storage
/// l1_block_number
/// { 0 => int }
/// l1_block_timestamp
/// { 1 => int }
pub(crate) fn block_state_contract() -> Contract {
    let predicates = vec![Predicate {
        state_read: vec![],
        constraints: vec![],
        directive: essential_types::predicate::Directive::Satisfy,
    }];

    let salt = essential_hash::hash(&"block-state-contract");
    Contract { predicates, salt }
}

pub(crate) fn block_state_contract_address() -> ContentAddress {
    let contract = block_state_contract();
    essential_hash::contract_addr::from_contract(&contract)
}

pub(crate) fn block_state_solution(l1_block_number: u64, l1_block_timestamp: u64) -> Solution {
    let contract = block_state_contract();
    let block_state_address = essential_hash::contract_addr::from_contract(&contract);
    let predicate = essential_hash::content_addr(&contract.predicates[0]);
    let predicate_to_solve = PredicateAddress {
        contract: block_state_address,
        predicate,
    };
    let l1_block_number = l1_block_number.try_into().unwrap();
    let l1_block_timestamp = l1_block_timestamp.try_into().unwrap();
    Solution {
        data: vec![SolutionData {
            predicate_to_solve,
            decision_variables: Default::default(),
            transient_data: Default::default(),
            state_mutations: vec![
                Mutation {
                    key: vec![0],
                    value: vec![l1_block_number],
                },
                Mutation {
                    key: vec![1],
                    value: vec![l1_block_timestamp],
                },
            ],
        }],
    }
}

#[test]
fn print_time_address() {
    let block_state_address = block_state_contract_address();
    let words = essential_types::convert::word_4_from_u8_32(block_state_address.0);

    let readme = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"));

    println!("{:?}", block_state_address);
    println!("{}", block_state_address);
    println!("{:?}", words);

    let readme_addr = readme
        .split("BlockState(")
        .nth(1)
        .unwrap()
        .split(')')
        .next()
        .unwrap();
    assert_eq!(readme_addr, format!("0x{}", block_state_address));
}