piecrust 0.30.0

Dusk's virtual machine for running WASM smart contracts.
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//
// Copyright (c) DUSK NETWORK. All rights reserved.

use crate::store::commit::Commit;
use crate::store::hasher::Hash;
use crate::store::index::{ContractIndexElement, NewContractIndex};
use piecrust_uplink::ContractId;
use std::collections::BTreeMap;
use std::collections::btree_map::Keys;

#[derive(Debug)]
pub struct CommitStore {
    commits: BTreeMap<Hash, Commit>,
    main_index: NewContractIndex,
}

impl CommitStore {
    pub fn new() -> Self {
        Self {
            commits: BTreeMap::new(),
            main_index: NewContractIndex::new(),
        }
    }

    pub fn insert_commit(&mut self, hash: Hash, commit: Commit) {
        self.commits.insert(hash, commit);
    }

    pub fn get_commit(&self, hash: &Hash) -> Option<&Commit> {
        self.commits.get(hash)
    }

    pub fn get_element_and_base(
        &self,
        hash: &Hash,
        contract_id: &ContractId,
    ) -> (Option<*const ContractIndexElement>, Option<Hash>) {
        match self.commits.get(hash) {
            Some(commit) => {
                let e = commit.index().get(contract_id);
                (e.map(|a| a as *const ContractIndexElement), commit.base())
            }
            None => {
                let e = self.main_index.get(contract_id);
                (e.map(|a| a as *const ContractIndexElement), None)
            }
        }
    }

    pub fn get_element_and_base_mut(
        &mut self,
        hash: &Hash,
        contract_id: &ContractId,
    ) -> (Option<*mut ContractIndexElement>, Option<Hash>) {
        match self.commits.get_mut(hash) {
            Some(commit) => {
                let e = commit.index_mut().get_mut(contract_id);
                (e.map(|a| a as *mut ContractIndexElement), commit.base())
            }
            None => {
                let e = self.main_index.get_mut(contract_id);
                (e.map(|a| a as *mut ContractIndexElement), None)
            }
        }
    }

    pub fn contains_key(&self, hash: &Hash) -> bool {
        self.commits.contains_key(hash)
    }

    pub fn keys(&self) -> Keys<'_, Hash, Commit> {
        self.commits.keys()
    }

    pub fn remove_commit(&mut self, hash: &Hash, deep: bool) {
        if deep {
            let mut elements_to_remove = BTreeMap::new();
            if let Some(removed_commit) = self.commits.get(hash) {
                for (contract_id, element) in
                    removed_commit.index().contracts().iter()
                {
                    if let Some(h) = element.hash() {
                        elements_to_remove.insert(*contract_id, h);
                    }
                }
            }
            // copy finalized elements from other commits to main
            for (h, commit) in self.commits.iter_mut() {
                if *h == *hash {
                    continue;
                }
                for (c, hh) in elements_to_remove.iter() {
                    if let Some(el) = commit.index().get(c) {
                        if let Some(el_hash) = el.hash() {
                            if el_hash == *hh {
                                if let Some(element) = commit.index().get(c) {
                                    self.main_index.insert_contract_index(
                                        c,
                                        element.clone(),
                                    );
                                }
                            }
                        }
                    }
                }
            }
        }
        self.commits.remove(hash);
    }

    pub fn insert_main_index(
        &mut self,
        contract_id: &ContractId,
        element: ContractIndexElement,
    ) {
        self.main_index.insert_contract_index(contract_id, element);
    }

    pub fn get_from_main_index(
        &mut self,
        contract_id: &ContractId,
    ) -> Option<&ContractIndexElement> {
        self.main_index.get(contract_id)
    }
}