zk_evm_abstractions/
auxiliary.rs

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
use crate::vm::MemoryType;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct Timestamp(pub u32);

impl Timestamp {
    pub const fn empty() -> Self {
        Self(0)
    }
}

impl std::cmp::PartialOrd for Timestamp {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.0.partial_cmp(&other.0)
    }
}

impl std::cmp::Ord for Timestamp {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.0.cmp(&other.0)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct MemoryIndex(pub u32);

impl MemoryIndex {
    pub const fn empty() -> Self {
        Self(0)
    }
}

impl std::cmp::PartialOrd for MemoryIndex {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.0.partial_cmp(&other.0)
    }
}

impl std::cmp::Ord for MemoryIndex {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.0.cmp(&other.0)
    }
}

impl MemoryIndex {
    pub fn increment_unchecked(&mut self) {
        self.0 = self.0.wrapping_add(1u32);
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct MemoryOffset(pub u32);

impl std::cmp::PartialOrd for MemoryOffset {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.0.partial_cmp(&other.0)
    }
}

impl std::cmp::Ord for MemoryOffset {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.0.cmp(&other.0)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct MemoryPage(pub u32);

impl MemoryPage {
    pub const fn empty() -> Self {
        Self(0)
    }
}

impl std::cmp::PartialOrd for MemoryPage {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.0.partial_cmp(&other.0)
    }
}

impl std::cmp::Ord for MemoryPage {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.0.cmp(&other.0)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct MemoryLocation {
    pub memory_type: MemoryType,
    pub page: MemoryPage,
    pub index: MemoryIndex,
}

impl MemoryLocation {
    pub const fn empty() -> Self {
        Self {
            memory_type: MemoryType::Heap,
            page: MemoryPage::empty(),
            index: MemoryIndex::empty(),
        }
    }
}

impl std::cmp::PartialOrd for MemoryLocation {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl std::cmp::Ord for MemoryLocation {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        let tt = self.page.cmp(&other.page);
        if tt != std::cmp::Ordering::Equal {
            return tt;
        }

        let tt = self.index.cmp(&other.index);
        if tt != std::cmp::Ordering::Equal {
            return tt;
        }

        std::cmp::Ordering::Equal
    }
}

impl MemoryLocation {
    #[inline]
    pub const fn add_offset(&self, offset: MemoryOffset) -> Self {
        Self {
            memory_type: self.memory_type,
            page: self.page,
            index: MemoryIndex(self.index.0.wrapping_add(offset.0)),
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct MemoryKey {
    pub location: MemoryLocation,
    pub timestamp: Timestamp,
}

impl std::cmp::PartialOrd for MemoryKey {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl std::cmp::Ord for MemoryKey {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        let tt = self.location.cmp(&other.location);
        if tt != std::cmp::Ordering::Equal {
            return tt;
        }

        let tt = self.timestamp.cmp(&other.timestamp);
        if tt != std::cmp::Ordering::Equal {
            return tt;
        }

        std::cmp::Ordering::Equal
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct PubdataCost(pub i32);