1use elf::abi::{PF_NONE, PF_R, PF_W, PF_X};
2
3pub const MAXIMUM_MEMORY_SIZE: u64 = (1u64 << 48) - 1;
5
6pub const MAX_JIT_LOG_ADDR: usize = 40;
8
9pub const BYTE_SIZE: usize = 8;
11
12pub const LIMB_SIZE: usize = 16;
14
15pub const WORD_SIZE: usize = 4;
17
18pub const WORD_BYTE_SIZE: usize = 2 * WORD_SIZE;
20
21pub const INSTRUCTION_WORD_SIZE: usize = 4;
23
24pub const LONG_WORD_BYTE_SIZE: usize = 2 * WORD_BYTE_SIZE;
26
27pub const LOG_PAGE_SIZE: usize = 12;
29
30pub const PAGE_SIZE: usize = 1 << LOG_PAGE_SIZE;
32
33pub const PROT_NONE: u8 = PF_NONE as u8;
35pub const PROT_READ: u8 = PF_R as u8;
36pub const PROT_WRITE: u8 = PF_W as u8;
37pub const PROT_EXEC: u8 = PF_X as u8;
38pub const DEFAULT_PAGE_PROT: u8 = PROT_READ | PROT_WRITE;
39
40pub const NOTE_UNTRUSTED_PROGRAM_ENABLED: u32 = 1;
42
43pub const STACK_TOP: u64 = 0x78000000;
45
46pub mod fd {
47 pub const LOWEST_ALLOWED_FD: u32 = 10;
53
54 macro_rules! create_fd {
56 ($(
57 #[$attr:meta]
58 pub const $name:ident: u32 = $value:expr;
59 )*) => {
60 $(
61 #[$attr]
62 pub const $name: u32 = $value + $crate::consts::fd::LOWEST_ALLOWED_FD;
63 )*
64 }
65 }
66
67 create_fd! {
68 pub const FD_PUBLIC_VALUES: u32 = 3;
70
71 pub const FD_HINT: u32 = 4;
73
74 pub const FD_ECRECOVER_HOOK: u32 = 5;
76
77 pub const FD_EDDECOMPRESS: u32 = 6;
79
80 pub const FD_RSA_MUL_MOD: u32 = 7;
82
83 pub const FD_BLS12_381_SQRT: u32 = 8;
85
86 pub const FD_BLS12_381_INVERSE: u32 = 9;
88
89 pub const FD_FP_SQRT: u32 = 10;
91
92 pub const FD_FP_INV: u32 = 11;
94 }
95}
96
97pub fn words_to_bytes_le_vec<'a>(words: impl IntoIterator<Item = &'a u64>) -> Vec<u8> {
99 words.into_iter().flat_map(|word| word.to_le_bytes().into_iter()).collect::<Vec<_>>()
100}
101
102pub fn words_to_bytes_le<'a, const B: usize>(words: impl IntoIterator<Item = &'a u64>) -> [u8; B] {
104 let mut iter = words.into_iter().flat_map(|word| word.to_le_bytes().into_iter());
105 core::array::from_fn(|_| iter.next().unwrap())
106}
107
108pub fn bytes_to_words_le<const W: usize>(bytes: &[u8]) -> [u64; W] {
110 debug_assert_eq!(bytes.len(), W * 8);
111 let mut iter = bytes.chunks_exact(8).map(|chunk| u64::from_le_bytes(chunk.try_into().unwrap()));
112 core::array::from_fn(|_| iter.next().unwrap())
113}
114
115pub fn bytes_to_words_le_vec(bytes: &[u8]) -> Vec<u64> {
117 bytes
118 .chunks_exact(8)
119 .map(|chunk| u64::from_le_bytes(chunk.try_into().unwrap()))
120 .collect::<Vec<_>>()
121}
122
123pub fn num_to_comma_separated<T: ToString>(value: T) -> String {
125 value
126 .to_string()
127 .chars()
128 .rev()
129 .collect::<Vec<_>>()
130 .chunks(3)
131 .map(|chunk| chunk.iter().collect::<String>())
132 .collect::<Vec<_>>()
133 .join(",")
134 .chars()
135 .rev()
136 .collect()
137}
138
139pub fn u32_to_u64(limbs: &[u32]) -> Vec<u64> {
141 debug_assert!(limbs.len().is_multiple_of(2), "need an even number of u32s");
142 limbs.chunks_exact(2).map(|pair| (pair[0] as u64) | ((pair[1] as u64) << 32)).collect()
143}
144
145pub fn u64_to_u32<'a>(limbs: impl IntoIterator<Item = &'a u64>) -> Vec<u32> {
147 limbs
148 .into_iter()
149 .flat_map(|x| {
150 let lo = *x as u32;
151 let hi = (*x >> 32) as u32;
152 [lo, hi]
153 })
154 .collect()
155}
156
157pub fn u32_to_u16_limbs(value: u32) -> [u16; 2] {
159 [(value & 0xFFFF) as u16, (value >> 16) as u16]
160}
161
162pub fn u64_to_u16_limbs(value: u64) -> [u16; 4] {
164 [(value & 0xFFFF) as u16, (value >> 16) as u16, (value >> 32) as u16, (value >> 48) as u16]
165}
166
167pub fn split_page_idx(page_idx: u64) -> [u16; 3] {
170 [(page_idx & 0xF) as u16, ((page_idx >> 4) & 0xFFFF) as u16, ((page_idx >> 20) & 0xFFFF) as u16]
171}