ovmi 0.3.0

Optimstic virtual machine interperter
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

use crate::executor::*;
use crate::predicates::*;

pub struct VerifyInclusionPredicate<'a, Ext: ExternalCall> {
    pub ext: &'a Ext,
}

impl<'a, Ext: ExternalCall> AtomicPredicateInterface<AddressOf<Ext>>
    for VerifyInclusionPredicate<'a, Ext>
{
    fn decide(&self, inputs: Vec<Vec<u8>>) -> ExecResult<AddressOf<Ext>> {
        require!(inputs.len() > 4);
        let address = Ext::bytes_to_address(&inputs[1])?;
        Ok(self.ext.ext_verify_inclusion_with_root(
            Ext::hash_of(&inputs[0]),
            address,
            &inputs[2][..], // range
            &inputs[3][..], // inclusionProof
            &inputs[4][..], // bytes32
        ))
    }
}
impl<'a, Ext: ExternalCall> AtomicHelperInterface<AddressOf<Ext>>
    for VerifyInclusionPredicate<'a, Ext>
{
    type Hash = HashOf<Ext>;
    fn ext_address(&self) -> AddressOf<Ext> {
        self.ext.ext_address()
    }
    fn ext_set_predicate_decision(
        &self,
        game_id: Self::Hash,
        decision: bool,
    ) -> ExecResult<AddressOf<Ext>> {
        self.ext.ext_set_predicate_decision(game_id, decision)
    }
    fn ext_get_property_id(&self, property: &Property<AddressOf<Ext>>) -> Self::Hash {
        self.ext.ext_get_property_id(property)
    }
}

impl<'a, Ext: ExternalCall> DecidablePredicateInterface<AddressOf<Ext>>
    for VerifyInclusionPredicate<'a, Ext>
{
    fn decide_with_witness(
        &self,
        inputs: Vec<Vec<u8>>,
        _witness: Vec<Vec<u8>>,
    ) -> ExecResult<AddressOf<Ext>> {
        Self::decide(self, inputs)
    }
}

impl<'a, Ext: ExternalCall> BaseAtomicPredicateInterface<AddressOf<Ext>>
    for VerifyInclusionPredicate<'a, Ext>
{
}