sui_indexer/models/
event_indices.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use crate::{
5    schema::{
6        event_emit_module, event_emit_package, event_senders, event_struct_instantiation,
7        event_struct_module, event_struct_name, event_struct_package,
8    },
9    types::EventIndex,
10};
11use diesel::prelude::*;
12
13#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
14#[diesel(table_name = event_emit_package)]
15pub struct StoredEventEmitPackage {
16    pub tx_sequence_number: i64,
17    pub event_sequence_number: i64,
18    pub package: Vec<u8>,
19    pub sender: Vec<u8>,
20}
21
22#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
23#[diesel(table_name = event_emit_module)]
24pub struct StoredEventEmitModule {
25    pub tx_sequence_number: i64,
26    pub event_sequence_number: i64,
27    pub package: Vec<u8>,
28    pub module: String,
29    pub sender: Vec<u8>,
30}
31
32#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
33#[diesel(table_name = event_senders)]
34pub struct StoredEventSenders {
35    pub tx_sequence_number: i64,
36    pub event_sequence_number: i64,
37    pub sender: Vec<u8>,
38}
39
40#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
41#[diesel(table_name = event_struct_package)]
42pub struct StoredEventStructPackage {
43    pub tx_sequence_number: i64,
44    pub event_sequence_number: i64,
45    pub package: Vec<u8>,
46    pub sender: Vec<u8>,
47}
48
49#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
50#[diesel(table_name = event_struct_module)]
51pub struct StoredEventStructModule {
52    pub tx_sequence_number: i64,
53    pub event_sequence_number: i64,
54    pub package: Vec<u8>,
55    pub module: String,
56    pub sender: Vec<u8>,
57}
58
59#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
60#[diesel(table_name = event_struct_name)]
61pub struct StoredEventStructName {
62    pub tx_sequence_number: i64,
63    pub event_sequence_number: i64,
64    pub package: Vec<u8>,
65    pub module: String,
66    pub type_name: String,
67    pub sender: Vec<u8>,
68}
69
70#[derive(Queryable, Insertable, Selectable, Debug, Clone, Default)]
71#[diesel(table_name = event_struct_instantiation)]
72pub struct StoredEventStructInstantiation {
73    pub tx_sequence_number: i64,
74    pub event_sequence_number: i64,
75    pub package: Vec<u8>,
76    pub module: String,
77    pub type_instantiation: String,
78    pub sender: Vec<u8>,
79}
80
81impl EventIndex {
82    pub fn split(
83        self: EventIndex,
84    ) -> (
85        StoredEventEmitPackage,
86        StoredEventEmitModule,
87        StoredEventSenders,
88        StoredEventStructPackage,
89        StoredEventStructModule,
90        StoredEventStructName,
91        StoredEventStructInstantiation,
92    ) {
93        let tx_sequence_number = self.tx_sequence_number as i64;
94        let event_sequence_number = self.event_sequence_number as i64;
95        (
96            StoredEventEmitPackage {
97                tx_sequence_number,
98                event_sequence_number,
99                package: self.emit_package.to_vec(),
100                sender: self.sender.to_vec(),
101            },
102            StoredEventEmitModule {
103                tx_sequence_number,
104                event_sequence_number,
105                package: self.emit_package.to_vec(),
106                module: self.emit_module.clone(),
107                sender: self.sender.to_vec(),
108            },
109            StoredEventSenders {
110                tx_sequence_number,
111                event_sequence_number,
112                sender: self.sender.to_vec(),
113            },
114            StoredEventStructPackage {
115                tx_sequence_number,
116                event_sequence_number,
117                package: self.type_package.to_vec(),
118                sender: self.sender.to_vec(),
119            },
120            StoredEventStructModule {
121                tx_sequence_number,
122                event_sequence_number,
123                package: self.type_package.to_vec(),
124                module: self.type_module.clone(),
125                sender: self.sender.to_vec(),
126            },
127            StoredEventStructName {
128                tx_sequence_number,
129                event_sequence_number,
130                package: self.type_package.to_vec(),
131                module: self.type_module.clone(),
132                type_name: self.type_name.clone(),
133                sender: self.sender.to_vec(),
134            },
135            StoredEventStructInstantiation {
136                tx_sequence_number,
137                event_sequence_number,
138                package: self.type_package.to_vec(),
139                module: self.type_module.clone(),
140                type_instantiation: self.type_instantiation.clone(),
141                sender: self.sender.to_vec(),
142            },
143        )
144    }
145}