zkevm_opcode_defs 0.153.11

ZKsync EraVM opcode definitions
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

use super::*;

// Note: offsets and length params below can be byte or word, or in general
// callee's interpreted
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PrecompileCallABI {
    pub input_memory_offset: u32,
    pub input_memory_length: u32,
    pub output_memory_offset: u32,
    pub output_memory_length: u32,
    pub memory_page_to_read: u32,
    pub memory_page_to_write: u32,
    pub precompile_interpreted_data: u64,
}

impl PrecompileCallABI {
    pub const fn from_u256(raw_value: U256) -> Self {
        let raw = raw_value.0;
        let input_memory_offset = raw[0] as u32;
        let input_memory_length = (raw[0] >> 32) as u32;
        let output_memory_offset = raw[1] as u32;
        let output_memory_length = (raw[1] >> 32) as u32;
        let memory_page_to_read = raw[2] as u32;
        let memory_page_to_write = (raw[2] >> 32) as u32;
        let precompile_interpreted_data = raw[3];

        Self {
            input_memory_offset,
            input_memory_length,
            output_memory_offset,
            output_memory_length,
            memory_page_to_read,
            memory_page_to_write,
            precompile_interpreted_data,
        }
    }

    pub const fn to_u256(self) -> U256 {
        let mut result = U256::zero();
        result.0[0] = (self.input_memory_offset as u64) | ((self.input_memory_length as u64) << 32);
        result.0[1] =
            (self.output_memory_offset as u64) | ((self.output_memory_length as u64) << 32);
        result.0[2] =
            (self.memory_page_to_read as u64) | ((self.memory_page_to_write as u64) << 32);
        result.0[3] = self.precompile_interpreted_data;

        result
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PrecompileAuxData {
    pub extra_ergs_cost: u32,
    pub extra_pubdata_cost: u32,
}

impl PrecompileAuxData {
    pub const fn from_u256(raw_value: U256) -> Self {
        let raw = raw_value.0;
        let extra_ergs_cost = raw[0] as u32;
        let extra_pubdata_cost = (raw[0] >> 32) as u32;

        Self {
            extra_ergs_cost,
            extra_pubdata_cost,
        }
    }

    pub const fn to_u256(self) -> U256 {
        let mut result = U256::zero();
        result.0[0] = (self.extra_ergs_cost as u64) | ((self.extra_pubdata_cost as u64) << 32);

        result
    }
}