psibase/
native_tables.rs

1#![allow(non_snake_case)]
2
3use crate::{
4    AccountNumber, Action, BlockHeader, BlockInfo, BlockNum, Checksum256, Claim, DbId, Hex,
5    JointConsensus, MethodNumber, MicroSeconds, Pack, ToSchema, Unpack,
6};
7use serde::{Deserialize, Serialize};
8
9pub type NativeTable = u16;
10pub type NativeIndex = u8;
11
12pub const STATUS_TABLE: NativeTable = 1;
13pub const CODE_TABLE: NativeTable = 2;
14pub const CODE_BY_HASH_TABLE: NativeTable = 3;
15pub const DATABASE_STATUS_TABLE: NativeTable = 4;
16pub const TRANSACTION_WASM_CONFIG_TABLE: NativeTable = 5;
17pub const PROOF_WASM_CONFIG_TABLE: NativeTable = 6; // Also for first auth
18pub const CONFIG_TABLE: NativeTable = 7;
19pub const NOTIFY_TABLE: NativeTable = 8;
20pub const BLOCK_DATA_TABLE: NativeTable = 9;
21pub const CONSENSUS_CHANGE_TABLE: NativeTable = 10;
22pub const SNAPSHOT_TABLE: NativeTable = 11;
23pub const SCHEDULED_SNAPSHOT_TABLE: NativeTable = 12;
24pub const LOG_TRUNCATE_TABLE: NativeTable = 13;
25pub const SOCKET_TABLE: NativeTable = 14;
26pub const RUN_TABLE: NativeTable = 15;
27
28pub const NATIVE_TABLE_PRIMARY_INDEX: NativeIndex = 0;
29
30pub fn status_key() -> (NativeTable, NativeIndex) {
31    (STATUS_TABLE, NATIVE_TABLE_PRIMARY_INDEX)
32}
33
34#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
35#[fracpack(fracpack_mod = "fracpack")]
36pub struct StatusRow {
37    pub chainId: Checksum256,
38    pub current: BlockHeader,
39    pub head: Option<BlockInfo>,
40    pub consensus: JointConsensus,
41}
42
43impl StatusRow {
44    pub const DB: DbId = DbId::Native;
45
46    pub fn key(&self) -> (NativeTable, NativeIndex) {
47        status_key()
48    }
49}
50
51#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
52#[fracpack(fracpack_mod = "fracpack")]
53pub struct ConfigRow {
54    pub maxKeySize: u32,
55    pub maxValueSize: u32,
56}
57
58impl ConfigRow {
59    pub const DB: DbId = DbId::Native;
60
61    pub fn key(&self) -> (NativeTable, NativeIndex) {
62        (CONFIG_TABLE, NATIVE_TABLE_PRIMARY_INDEX)
63    }
64}
65
66#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
67#[fracpack(fracpack_mod = "fracpack")]
68pub struct VMOptions {
69    max_mutable_global_bytes: u32,
70    max_pages: u32,
71    max_table_elements: u32,
72    max_stack_bytes: u32,
73}
74
75#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
76#[fracpack(fracpack_mod = "fracpack")]
77pub struct WasmConfigRow {
78    numExecutionMemories: u32,
79    vmOptions: VMOptions,
80}
81
82impl WasmConfigRow {
83    pub const DB: DbId = DbId::Native;
84    pub fn key(table: NativeTable) -> (NativeTable, NativeIndex) {
85        (table, NATIVE_TABLE_PRIMARY_INDEX)
86    }
87}
88
89#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
90#[fracpack(fracpack_mod = "fracpack")]
91pub struct CodeRow {
92    pub codeNum: AccountNumber,
93    pub flags: u64,
94
95    pub codeHash: Checksum256,
96    pub vmType: u8,
97    pub vmVersion: u8,
98}
99
100impl CodeRow {
101    pub const DB: DbId = DbId::Native;
102    pub const IS_PRIVILEGED: u64 = 1u64 << 0;
103    pub const IS_VERIFY: u64 = 1u64 << 1;
104    pub const RUN_MODE_RPC: u64 = 1u64 << 2;
105    pub const RUN_MODE_CALLBACK: u64 = 2u64 << 2;
106    pub const IS_REPLACEMENT: u64 = 1u64 << 32;
107    pub fn key(&self) -> (NativeTable, NativeIndex, AccountNumber) {
108        (CODE_TABLE, NATIVE_TABLE_PRIMARY_INDEX, self.codeNum)
109    }
110}
111
112/// where code is actually stored, duplicate services are reused
113#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
114#[fracpack(fracpack_mod = "fracpack")]
115pub struct CodeByHashRow {
116    pub codeHash: Checksum256,
117    pub vmType: u8,
118    pub vmVersion: u8,
119
120    pub code: Hex<Vec<u8>>,
121}
122
123impl CodeByHashRow {
124    pub const DB: DbId = DbId::Native;
125    pub fn key(&self) -> (NativeTable, NativeIndex, Checksum256, u8, u8) {
126        (
127            CODE_BY_HASH_TABLE,
128            NATIVE_TABLE_PRIMARY_INDEX,
129            self.codeHash.clone(),
130            self.vmType,
131            self.vmVersion,
132        )
133    }
134}
135
136#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
137#[fracpack(fracpack_mod = "fracpack")]
138pub struct DatabaseStatusRow {
139    nextHistoryEventNumber: u64,
140    nextUIEventNumber: u64,
141    nextMerkleEventNumber: u64,
142
143    blockMerkleEventNumber: u64,
144}
145
146impl DatabaseStatusRow {
147    pub const DB: DbId = DbId::Native;
148    pub fn key(&self) -> (NativeTable, NativeIndex) {
149        (DATABASE_STATUS_TABLE, NATIVE_TABLE_PRIMARY_INDEX)
150    }
151}
152
153#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
154#[fracpack(fracpack_mod = "fracpack")]
155pub struct NotifyRow {
156    type_: u32,
157    actions: Vec<Action>,
158}
159
160impl NotifyRow {
161    pub const DB: DbId = DbId::Native;
162    pub fn key(&self) -> (NativeTable, NativeIndex) {
163        (NOTIFY_TABLE, NATIVE_TABLE_PRIMARY_INDEX)
164    }
165}
166
167#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
168#[fracpack(fracpack_mod = "fracpack")]
169pub struct BlockDataRow {
170    pub blockId: Checksum256,
171    pub auxConsensusData: Option<Hex<Vec<u8>>>,
172}
173
174impl BlockDataRow {
175    pub const DB: DbId = DbId::NativeSubjective;
176    pub fn key(&self) -> (NativeTable, NativeIndex, Checksum256) {
177        (
178            BLOCK_DATA_TABLE,
179            NATIVE_TABLE_PRIMARY_INDEX,
180            self.blockId.clone(),
181        )
182    }
183}
184
185#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
186#[fracpack(fracpack_mod = "fracpack")]
187pub struct ConsensusChangeRow {
188    pub start: BlockNum,
189    pub commit: BlockNum,
190    pub end: BlockNum,
191}
192
193impl ConsensusChangeRow {
194    pub const DB: DbId = DbId::NativeSubjective;
195    pub fn key(&self) -> (NativeTable, NativeIndex, BlockNum) {
196        (
197            CONSENSUS_CHANGE_TABLE,
198            NATIVE_TABLE_PRIMARY_INDEX,
199            self.start,
200        )
201    }
202}
203
204#[derive(Debug, Clone, PartialEq, Eq, Pack, Unpack, ToSchema, Serialize, Deserialize)]
205#[fracpack(fracpack_mod = "fracpack")]
206pub struct StateChecksum {
207    pub serviceRoot: Checksum256,
208    pub nativeRoot: Checksum256,
209}
210
211#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
212#[fracpack(fracpack_mod = "fracpack")]
213pub struct StateSignature {
214    pub account: AccountNumber,
215    pub claim: Claim,
216    pub rawData: Hex<Vec<u8>>,
217}
218
219#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
220#[fracpack(fracpack_mod = "fracpack")]
221pub struct SnapshotStateItem {
222    pub state: StateChecksum,
223    pub signatures: Vec<StateSignature>,
224}
225
226#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
227#[fracpack(fracpack_mod = "fracpack")]
228pub struct SnapshotRow {
229    pub id: Checksum256,
230    pub state: Option<SnapshotStateItem>,
231    pub other: Vec<SnapshotStateItem>,
232}
233
234impl SnapshotRow {
235    pub const DB: DbId = DbId::NativeSubjective;
236    pub fn key(&self) -> (NativeTable, NativeIndex, Checksum256) {
237        (SNAPSHOT_TABLE, NATIVE_TABLE_PRIMARY_INDEX, self.id.clone())
238    }
239}
240
241#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
242#[fracpack(fracpack_mod = "fracpack")]
243pub struct ScheduledSnapshotRow {
244    pub blockNum: BlockNum,
245}
246
247impl ScheduledSnapshotRow {
248    pub const DB: DbId = DbId::Native;
249    pub fn key(&self) -> (NativeTable, NativeIndex, BlockNum) {
250        (
251            SCHEDULED_SNAPSHOT_TABLE,
252            NATIVE_TABLE_PRIMARY_INDEX,
253            self.blockNum,
254        )
255    }
256}
257
258// If this row is present it indicates the height the block log starts at.
259#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
260#[fracpack(fracpack_mod = "fracpack")]
261pub struct LogTruncateRow {
262    pub start: BlockNum,
263}
264
265impl LogTruncateRow {
266    pub const DB: DbId = DbId::NativeSubjective;
267    pub fn key(&self) -> (NativeTable, NativeIndex) {
268        (LOG_TRUNCATE_TABLE, NATIVE_TABLE_PRIMARY_INDEX)
269    }
270}
271
272#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
273#[fracpack(fracpack_mod = "fracpack")]
274pub struct ProducerMultiCastSocketInfo {}
275
276#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
277#[fracpack(fracpack_mod = "fracpack")]
278pub struct HttpSocketInfo {}
279
280#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
281#[fracpack(fracpack_mod = "fracpack")]
282pub enum SocketInfo {
283    ProducerMultiCastSocketInfo(ProducerMultiCastSocketInfo),
284    HttpSocketInfo(HttpSocketInfo),
285}
286
287#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
288#[fracpack(fracpack_mod = "fracpack")]
289pub struct SocketRow {
290    fd: i32,
291    info: SocketInfo,
292}
293
294impl SocketRow {
295    // Well-known fds
296    pub const PRODUCER_MULTICAST: i32 = 0;
297
298    pub const DB: DbId = DbId::NativeSubjective;
299    pub fn key(&self) -> (NativeTable, NativeIndex, i32) {
300        (SOCKET_TABLE, NATIVE_TABLE_PRIMARY_INDEX, self.fd)
301    }
302}
303
304#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
305#[fracpack(fracpack_mod = "fracpack")]
306pub struct RunMode(u8);
307
308impl RunMode {
309    pub const VERIFY: RunMode = RunMode(0);
310    pub const SPECULATIVE: RunMode = RunMode(1);
311    pub const RPC: RunMode = RunMode(2);
312    pub const CALLBACK: RunMode = RunMode(3);
313}
314
315pub type RunToken = Vec<u8>;
316
317#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
318#[fracpack(fracpack_mod = "fracpack")]
319pub struct BoundMethod {
320    service: AccountNumber,
321    method: MethodNumber,
322}
323
324#[derive(Debug, Clone, Pack, Unpack, ToSchema, Serialize, Deserialize)]
325#[fracpack(fracpack_mod = "fracpack")]
326pub struct RunRow {
327    id: u64,
328    mode: RunMode,
329    maxTime: MicroSeconds,
330    action: Action,
331    continuation: BoundMethod,
332}
333
334impl RunRow {
335    pub const DB: DbId = DbId::NativeSubjective;
336    pub fn key(&self) -> (NativeTable, NativeIndex, u64) {
337        (RUN_TABLE, NATIVE_TABLE_PRIMARY_INDEX, self.id)
338    }
339}
psibase/native_tables.rs

psibase/
native_tables.rs
