Source file sc_rollup_storage.ml
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
open Sc_rollup_errors
module Store = Storage.Sc_rollup
module Commitment = Sc_rollup_commitment_repr
module Commitment_hash = Commitment.Hash
(** [address_from_nonce ctxt nonce] produces an address completely determined by
an operation hash and an origination counter, and accounts for gas spent. *)
let address_from_nonce ctxt nonce =
let open Tzresult_syntax in
let* ctxt =
Raw_context.consume_gas ctxt Sc_rollup_costs.Constants.cost_serialize_nonce
in
match Data_encoding.Binary.to_bytes_opt Origination_nonce.encoding nonce with
| None -> error Sc_rollup_address_generation
| Some nonce_bytes ->
let bytes_len = Bytes.length nonce_bytes in
let+ ctxt =
Raw_context.consume_gas
ctxt
(Sc_rollup_costs.cost_hash_bytes ~bytes_len)
in
(ctxt, Sc_rollup_repr.Address.hash_bytes [nonce_bytes])
let originate ctxt ~kind ~boot_sector ~parameters_ty ~genesis_commitment =
let open Lwt_tzresult_syntax in
let*? ctxt, genesis_commitment_hash =
Sc_rollup_commitment_storage.hash ctxt genesis_commitment
in
let*? ctxt, nonce = Raw_context.increment_origination_nonce ctxt in
let level = Raw_context.current_level ctxt in
let*? ctxt, address = address_from_nonce ctxt nonce in
let* ctxt, pvm_kind_size, _kind_existed =
Store.PVM_kind.add ctxt address kind
in
let* ctxt, genesis_info_size, _info_existed =
Store.Genesis_info.add
ctxt
address
{commitment_hash = genesis_commitment_hash; level = level.level}
in
let* ctxt, boot_sector_size, _sector_existed =
Store.Boot_sector.add ctxt address boot_sector
in
let* ctxt, param_ty_size_diff, _added =
Store.Parameters_type.add ctxt address parameters_ty
in
let*! inbox =
Sc_rollup_inbox_repr.empty (Raw_context.recover ctxt) address level.level
in
let* ctxt, inbox_size_diff = Store.Inbox.init ctxt address inbox in
let* ctxt, lcc_size_diff =
Store.Last_cemented_commitment.init ctxt address genesis_commitment_hash
in
let* ctxt, commitment_size_diff, _was_bound =
Store.Commitments.add
(ctxt, address)
genesis_commitment_hash
genesis_commitment
in
let* ctxt, commitment_added_size_diff, _commitment_existed =
Store.Commitment_added.add
(ctxt, address)
genesis_commitment_hash
level.level
in
let* ctxt, commitment_staker_count_size_diff, _commitment_staker_existed =
Store.Commitment_stake_count.add
(ctxt, address)
genesis_commitment_hash
Int32.zero
in
let* ctxt, stakers_size_diff = Store.Staker_count.init ctxt address 0l in
let addresses_size = 2 * Sc_rollup_repr.Address.size in
let stored_kind_size = 2 in
let origination_size = Constants_storage.sc_rollup_origination_size ctxt in
let size =
Z.of_int
(origination_size + stored_kind_size + boot_sector_size + addresses_size
+ inbox_size_diff + lcc_size_diff + commitment_size_diff
+ commitment_added_size_diff + commitment_staker_count_size_diff
+ stakers_size_diff + param_ty_size_diff + pvm_kind_size
+ genesis_info_size)
in
return (address, size, genesis_commitment_hash, ctxt)
let kind ctxt address =
let open Lwt_tzresult_syntax in
let* ctxt, kind_opt = Store.PVM_kind.find ctxt address in
match kind_opt with
| Some k -> return (ctxt, k)
| None -> fail (Sc_rollup_errors.Sc_rollup_does_not_exist address)
let list_unaccounted ctxt =
let open Lwt_syntax in
let+ res = Store.PVM_kind.keys_unaccounted ctxt in
Result.return res
let genesis_info ctxt rollup =
let open Lwt_tzresult_syntax in
let* ctxt, genesis_info = Store.Genesis_info.find ctxt rollup in
match genesis_info with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some genesis_info -> return (ctxt, genesis_info)
let get_boot_sector ctxt rollup =
let open Lwt_tzresult_syntax in
let* ctxt, boot_sector = Storage.Sc_rollup.Boot_sector.find ctxt rollup in
match boot_sector with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some boot_sector -> return (ctxt, boot_sector)
let parameters_type ctxt rollup =
let open Lwt_result_syntax in
let+ ctxt, res = Store.Parameters_type.find ctxt rollup in
(res, ctxt)
module Dal_slot = struct
open Dal_errors_repr
let slot_of_int_e n =
let open Tzresult_syntax in
match Dal_slot_repr.Index.of_int n with
| None -> fail Dal_errors_repr.Dal_slot_index_above_hard_limit
| Some slot_index -> return slot_index
let fail_if_slot_index_invalid ctxt slot_index =
let open Lwt_tzresult_syntax in
let*? max_slot_index =
slot_of_int_e @@ ((Raw_context.constants ctxt).dal.number_of_slots - 1)
in
if
Compare.Int.(
Dal_slot_repr.Index.compare slot_index max_slot_index > 0
|| Dal_slot_repr.Index.compare slot_index Dal_slot_repr.Index.zero < 0)
then
fail
Dal_errors_repr.(
Dal_subscribe_rollup_invalid_slot_index
{given = slot_index; maximum = max_slot_index})
else return slot_index
let all_indexes ctxt =
let max_slot_index = (Raw_context.constants ctxt).dal.number_of_slots - 1 in
Misc.(0 --> max_slot_index) |> List.map slot_of_int_e |> all_e
let subscribed_slots_at_level ctxt rollup level =
let open Lwt_tzresult_syntax in
let current_level = (Raw_context.current_level ctxt).level in
if Raw_level_repr.(level > current_level) then
fail (Dal_requested_subscriptions_at_future_level (current_level, level))
else
let*! subscription_levels =
Store.Slot_subscriptions.keys (ctxt, rollup)
in
let relevant_subscription_levels =
subscription_levels
|> List.filter (fun subscription_level ->
Raw_level_repr.(subscription_level <= level))
in
let last_subscription_level_opt =
List.fold_left
(fun max_level level ->
match max_level with
| None -> Some level
| Some max_level ->
Some
(if Raw_level_repr.(max_level > level) then max_level
else level))
None
relevant_subscription_levels
in
match last_subscription_level_opt with
| None -> return Bitset.empty
| Some subscription_level ->
Store.Slot_subscriptions.get (ctxt, rollup) subscription_level
let subscribe ctxt rollup ~slot_index =
let open Lwt_tzresult_syntax in
let* _slot_index = fail_if_slot_index_invalid ctxt slot_index in
let* _initial_level = genesis_info ctxt rollup in
let {Level_repr.level; _} = Raw_context.current_level ctxt in
let* subscribed_slots = subscribed_slots_at_level ctxt rollup level in
let*? slot_already_subscribed =
Bitset.mem subscribed_slots (Dal_slot_repr.Index.to_int slot_index)
in
if slot_already_subscribed then
fail (Dal_rollup_already_registered_to_slot (rollup, slot_index))
else
let*? subscribed_slots =
Bitset.add subscribed_slots (Dal_slot_repr.Index.to_int slot_index)
in
let*! ctxt =
Store.Slot_subscriptions.add (ctxt, rollup) level subscribed_slots
in
return (slot_index, level, ctxt)
let subscribed_slot_indices ctxt rollup level =
let all_indexes = all_indexes ctxt in
let to_dal_slot_index_list bitset =
let open Result_syntax in
let* all_indexes = all_indexes in
let+ slot_indexes =
all_indexes
|> List.map (fun i ->
let+ is_index_present =
Bitset.mem bitset (Dal_slot_repr.Index.to_int i)
in
if is_index_present then [i] else [])
|> all_e
in
List.concat slot_indexes
in
let open Lwt_tzresult_syntax in
let* _initial_level = genesis_info ctxt rollup in
let* subscribed_slots = subscribed_slots_at_level ctxt rollup level in
let*? result = to_dal_slot_index_list subscribed_slots in
return result
end