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
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

use crate::deploy::deploy;
use essential_memory_storage::MemoryStorage;
use essential_types::{
    contract::Contract,
    predicate::Predicate,
    solution::{Mutation, Solution, SolutionData},
    ContentAddress, PredicateAddress, Word,
};
use test_utils::{empty::Empty, sign_contract_with_random_keypair, solution_with_predicate};

// Empty valid solution.
// Sign an empty valid predicate and deploy it to newly created memory storage,
// create a solution with the signed predicate address.
pub async fn sanity_solution() -> (Solution, MemoryStorage) {
    let (predicate_address, storage) = deploy_predicate(Predicate::empty()).await;
    let solution = solution_with_predicate(predicate_address);
    (solution, storage)
}

// Sign and deploy given predicate to newly created memory storage.
pub async fn deploy_predicate(predicate: Predicate) -> (PredicateAddress, MemoryStorage) {
    deploy_predicate_to_storage(MemoryStorage::default(), predicate).await
}

pub async fn deploy_contracts(
    contracts: Vec<Contract>,
) -> (Vec<Vec<PredicateAddress>>, MemoryStorage) {
    let mut s = MemoryStorage::default();
    let mut addresses = Vec::new();
    for contract in contracts {
        let (addr, s2) = deploy_contract_to_storage(s, contract).await;
        s = s2;
        addresses.push(addr);
    }
    (addresses, s)
}

// Sign and deploy given predicate to newly created memory storage.
pub async fn deploy_predicate_to_storage(
    storage: MemoryStorage,
    predicate: Predicate,
) -> (PredicateAddress, MemoryStorage) {
    let predicate_hash = ContentAddress(essential_hash::hash(&predicate));
    let predicate = sign_contract_with_random_keypair(vec![predicate]);
    let result = deploy(&storage, predicate).await.unwrap();
    (
        PredicateAddress {
            contract: result,
            predicate: predicate_hash,
        },
        storage,
    )
}

pub async fn deploy_contract_to_storage(
    storage: MemoryStorage,
    contract: Contract,
) -> (Vec<PredicateAddress>, MemoryStorage) {
    let contract_hash = essential_hash::contract_addr::from_contract(&contract);
    let addresses = contract
        .iter()
        .map(|predicate| PredicateAddress {
            contract: contract_hash.clone(),
            predicate: essential_hash::content_addr(predicate),
        })
        .collect();
    let contract = sign_contract_with_random_keypair(contract);
    deploy(&storage, contract).await.unwrap();
    (addresses, storage)
}

pub fn test_predicate(salt: Word) -> Predicate {
    // Predicate that expects the value of previously uncontract state slot with index 0 to be 42.
    let mut predicate = Predicate::empty();
    // Program to read state slot 0.
    predicate.state_read = vec![essential_state_read_vm::asm::to_bytes(vec![
        essential_state_read_vm::asm::Stack::Push(1).into(),
        essential_state_read_vm::asm::StateSlots::AllocSlots.into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(4).into(), // key length
        essential_state_read_vm::asm::Stack::Push(1).into(), // delta
        essential_state_read_vm::asm::Stack::Push(0).into(), // slot index
        essential_state_read_vm::asm::StateRead::KeyRange,
        essential_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.
    predicate.constraints = vec![essential_constraint_vm::asm::to_bytes(vec![
        essential_constraint_vm::asm::Stack::Push(salt).into(), // Salt
        essential_constraint_vm::asm::Stack::Pop.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(), // slot
        essential_constraint_vm::asm::Stack::Push(0).into(), // pre
        essential_constraint_vm::asm::Access::StateLen.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Pred::Eq.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(), // slot
        essential_constraint_vm::asm::Stack::Push(1).into(), // post
        essential_constraint_vm::asm::Access::State.into(),
        essential_constraint_vm::asm::Stack::Push(42).into(),
        essential_constraint_vm::asm::Pred::Eq.into(),
        essential_constraint_vm::asm::Pred::And.into(),
    ])
    .collect()];
    predicate
}

// Solution that satisfies a predicate with state read and constraint programs.
pub async fn test_solution(
    storage: Option<MemoryStorage>,
    salt: Word,
) -> (Solution, MemoryStorage) {
    let (predicate_address, storage) =
        deploy_predicate_to_storage(storage.unwrap_or_default(), test_predicate(salt)).await;
    let mut solution = Solution::empty();
    let solution_decision_variables = vec![vec![42]];
    solution.data = vec![SolutionData {
        predicate_to_solve: predicate_address.clone(),
        decision_variables: solution_decision_variables,
        state_mutations: vec![Mutation {
            key: vec![0, 0, 0, 0],
            value: vec![42],
        }],
        transient_data: Default::default(),
    }];
    (solution, storage)
}

pub fn counter_predicate(salt: Word) -> Predicate {
    let mut predicate = Predicate::empty();
    predicate.state_read = vec![essential_state_read_vm::asm::to_bytes(vec![
        essential_state_read_vm::asm::Stack::Push(1).into(),
        essential_state_read_vm::asm::StateSlots::AllocSlots.into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(0).into(),
        essential_state_read_vm::asm::Stack::Push(4).into(), // key length
        essential_state_read_vm::asm::Stack::Push(1).into(), // delta
        essential_state_read_vm::asm::Stack::Push(0).into(), // slot index
        essential_state_read_vm::asm::StateRead::KeyRange,
        essential_state_read_vm::asm::TotalControlFlow::Halt.into(),
    ])
    .collect()];
    predicate.constraints = vec![essential_constraint_vm::asm::to_bytes(vec![
        // Salt
        essential_constraint_vm::asm::Stack::Push(salt).into(),
        essential_constraint_vm::asm::Stack::Pop.into(),
        // Jump distance
        essential_constraint_vm::asm::Stack::Push(2).into(),
        // Check if the state is not empty
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Access::StateLen.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Pred::Eq.into(),
        essential_constraint_vm::asm::Pred::Not.into(),
        // If not empty skip pushing 0
        essential_constraint_vm::asm::TotalControlFlow::JumpForwardIf.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        // Add 1 to the state or zero.
        // If state is empty then it won't push anything on the stack.
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Access::State.into(),
        essential_constraint_vm::asm::Stack::Push(1).into(),
        essential_constraint_vm::asm::Alu::Add.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Stack::Push(1).into(),
        essential_constraint_vm::asm::Access::State.into(),
        essential_constraint_vm::asm::Pred::Eq.into(),
        // Check the final value matches the dec var
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Access::DecisionVar.into(),
        essential_constraint_vm::asm::Stack::Push(0).into(),
        essential_constraint_vm::asm::Stack::Push(1).into(),
        essential_constraint_vm::asm::Access::State.into(),
        essential_constraint_vm::asm::Pred::Eq.into(),
        essential_constraint_vm::asm::Pred::And.into(),
    ])
    .collect()];
    predicate
}

pub async fn counter_solution(predicate_address: PredicateAddress, final_value: Word) -> Solution {
    let mut solution = Solution::empty();
    let solution_decision_variables = vec![vec![final_value]];
    solution.data = vec![SolutionData {
        predicate_to_solve: predicate_address.clone(),
        decision_variables: solution_decision_variables,
        state_mutations: vec![Mutation {
            key: vec![0, 0, 0, 0],
            value: vec![final_value],
        }],
        transient_data: Default::default(),
    }];
    solution
}