system_state_inner

Module0xfa65…814e

Move path: 0xfdc8…ea77::system_state_inner
Functions: 260 public, 0 entry
Structs: 1
Friend modules: system

system_state_inner

Bytecode2618 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v7

module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.system_state_inner {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::u128;

use 0000000000000000000000000000000000000000000000000000000000000001::u32;

use 0000000000000000000000000000000000000000000000000000000000000001::u64;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

use 356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::blob;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::bls_aggregate;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::encoding;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::epoch_parameters;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::event_blob;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::extended_field;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::messages;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::snapshot_blob;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_accounting;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_node;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_pool;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_resource;

struct SystemStateInnerV1 has store {

committee: BlsCommittee,

total_capacity_size: u64,

used_capacity_size: u64,

storage_price_per_unit_size: u64,

write_price_per_unit_size: u64,

future_accounting: FutureAccountingRingBuffer,

event_blob_certification_state: EventBlobCertificationState,

deny_list_sizes: ExtendedField<VecMap<ID, u64>>

}

public(friend) create_empty(Arg0: u32, Arg1: &mut TxContext): SystemStateInnerV1 {

L2: loc0: BlsCommittee

L3: loc1: EventBlobCertificationState

L4: loc2: FutureAccountingRingBuffer

B0:

0LdU32(0)

1VecPack(48, 0)

2Call bls_aggregate::new_bls_committee(u32, vector<BlsCommitteeMember>): BlsCommittee

3StLoc[2](loc0: BlsCommittee)

4CopyLoc[0](Arg0: u32)

5LdConst[0](u32: 1000)

6Le

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[1](Arg1: &mut TxContext)

10Pop

11LdConst[2](u64: 0)

12Abort

B3:

13MoveLoc[0](Arg0: u32)

14Call storage_accounting::ring_new(u32): FutureAccountingRingBuffer

15StLoc[4](loc2: FutureAccountingRingBuffer)

16Call event_blob::create_with_empty_state(): EventBlobCertificationState

17StLoc[3](loc1: EventBlobCertificationState)

18MoveLoc[2](loc0: BlsCommittee)

19LdU64(0)

20LdU64(0)

21LdU64(0)

22LdU64(0)

23MoveLoc[4](loc2: FutureAccountingRingBuffer)

24MoveLoc[3](loc1: EventBlobCertificationState)

25Call vec_map::empty<ID, u64>(): VecMap<ID, u64>

26MoveLoc[1](Arg1: &mut TxContext)

27Call extended_field::new<VecMap<ID, u64>>(VecMap<ID, u64>, &mut TxContext): ExtendedField<VecMap<ID, u64>>

28Pack[0](SystemStateInnerV1)

29Ret

}

public(friend) advance_epoch(Arg0: &mut SystemStateInnerV1, Arg1: BlsCommittee, Arg2: &EpochParams): VecMap<ID, Balance<WAL>> {

L3: loc0: u64

L4: loc1: u64

L5: loc2: u64

L6: loc3: Balance<WAL>

L7: loc4: &mut vector<Balance<WAL>>

L8: loc5: FutureAccounting

L9: loc6: u64

L10: loc7: &VecMap<ID, u64>

L11: loc8: u128

L12: loc9: u64

L13: loc10: u64

L14: loc11: u32

L15: loc12: ID

L16: loc13: vector<ID>

L17: loc14: Option<u64>

L18: loc15: BlsCommittee

L19: loc16: u32

L20: loc17: u64

L21: loc18: vector<Balance<WAL>>

L22: loc19: vector<Balance<WAL>>

L23: loc20: u64

L24: loc21: u64

L25: loc22: u64

L26: loc23: u128

L27: loc24: vector<u128>

L28: loc25: u128

L29: loc26: Balance<WAL>

L30: loc27: u128

L31: loc28: u128

L32: loc29: u128

L33: loc30: vector<u128>

L34: loc31: vector<u128>

L35: loc32: vector<ID>

L36: loc33: vector<ID>

L37: loc34: vector<u16>

L38: loc35: u16

L39: loc36: vector<u16>

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1FreezeRef

2Call epoch(&SystemStateInnerV1): u32

3StLoc[19](loc16: u32)

4CopyLoc[19](loc16: u32)

5LdU32(1)

6Add

7StLoc[14](loc11: u32)

8CopyLoc[0](Arg0: &mut SystemStateInnerV1)

9ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

10ReadRef

11StLoc[18](loc15: BlsCommittee)

12ImmBorrowLoc[1](Arg1: BlsCommittee)

13Call bls_aggregate::epoch(&BlsCommittee): u32

14MoveLoc[14](loc11: u32)

15Eq

16BrFalse(18)

B1:

17Branch(24)

B2:

18MoveLoc[0](Arg0: &mut SystemStateInnerV1)

19Pop

20MoveLoc[2](Arg2: &EpochParams)

21Pop

22LdConst[6](u64: 4)

23Abort

B3:

24MoveLoc[1](Arg1: BlsCommittee)

25CopyLoc[0](Arg0: &mut SystemStateInnerV1)

26MutBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

27WriteRef

28CopyLoc[0](Arg0: &mut SystemStateInnerV1)

29MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

30Call storage_accounting::ring_pop_expand(&mut FutureAccountingRingBuffer): FutureAccounting

31StLoc[8](loc5: FutureAccounting)

32ImmBorrowLoc[8](loc5: FutureAccounting)

33Call storage_accounting::epoch(&FutureAccounting): u32

34MoveLoc[19](loc16: u32)

35Eq

36BrFalse(38)

B4:

37Branch(44)

B5:

38MoveLoc[0](Arg0: &mut SystemStateInnerV1)

39Pop

40MoveLoc[2](Arg2: &EpochParams)

41Pop

42LdConst[7](u64: 5)

43Abort

B6:

44CopyLoc[0](Arg0: &mut SystemStateInnerV1)

45MutBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

46Call event_blob::reset(&mut EventBlobCertificationState)

47ImmBorrowLoc[8](loc5: FutureAccounting)

48Call storage_accounting::used_capacity(&FutureAccounting): u64

49StLoc[20](loc17: u64)

50CopyLoc[0](Arg0: &mut SystemStateInnerV1)

51MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

52LdU32(0)

53Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

54FreezeRef

55Call storage_accounting::used_capacity(&FutureAccounting): u64

56CopyLoc[0](Arg0: &mut SystemStateInnerV1)

57MutBorrowField[3](SystemStateInnerV1.used_capacity_size: u64)

58WriteRef

59MoveLoc[2](Arg2: &EpochParams)

60Call epoch_parameters::capacity(&EpochParams): u64

61CopyLoc[0](Arg0: &mut SystemStateInnerV1)

62ImmBorrowField[3](SystemStateInnerV1.used_capacity_size: u64)

63ReadRef

64Call u64::max(u64, u64): u64

65CopyLoc[0](Arg0: &mut SystemStateInnerV1)

66MutBorrowField[4](SystemStateInnerV1.total_capacity_size: u64)

67WriteRef

68MoveLoc[8](loc5: FutureAccounting)

69Call storage_accounting::unwrap_balance(FutureAccounting): Balance<WAL>

70StLoc[29](loc26: Balance<WAL>)

71CopyLoc[0](Arg0: &mut SystemStateInnerV1)

72ImmBorrowField[5](SystemStateInnerV1.deny_list_sizes: ExtendedField<VecMap<ID, u64>>)

73Call extended_field::borrow<VecMap<ID, u64>>(&ExtendedField<VecMap<ID, u64>>): &VecMap<ID, u64>

74StLoc[10](loc7: &VecMap<ID, u64>)

75ImmBorrowLoc[18](loc15: BlsCommittee)

76Call bls_aggregate::to_vec_map(&BlsCommittee): VecMap<ID, u16>

77Call vec_map::into_keys_values<ID, u16>(VecMap<ID, u16>): vector<ID> * vector<u16>

78StLoc[39](loc36: vector<u16>)

79StLoc[16](loc13: vector<ID>)

80LdConst[15](vector<u128>: 00)

81StLoc[27](loc24: vector<u128>)

82LdU128(0)

83StLoc[31](loc28: u128)

84CopyLoc[16](loc13: vector<ID>)

85StLoc[36](loc33: vector<ID>)

86MoveLoc[39](loc36: vector<u16>)

87StLoc[37](loc34: vector<u16>)

88MutBorrowLoc[37](loc34: vector<u16>)

89Call vector::reverse<u16>(&mut vector<u16>)

90ImmBorrowLoc[36](loc33: vector<ID>)

91VecLen(73)

92ImmBorrowLoc[37](loc34: vector<u16>)

93VecLen(29)

94Eq

95BrFalse(97)

B7:

96Branch(103)

B8:

97MoveLoc[0](Arg0: &mut SystemStateInnerV1)

98Pop

99MoveLoc[10](loc7: &VecMap<ID, u64>)

100Pop

101LdU64(13906834900192854015)

102Abort

B9:

103MoveLoc[36](loc33: vector<ID>)

104StLoc[35](loc32: vector<ID>)

105MutBorrowLoc[35](loc32: vector<ID>)

106Call vector::reverse<ID>(&mut vector<ID>)

107ImmBorrowLoc[35](loc32: vector<ID>)

108VecLen(73)

109StLoc[4](loc1: u64)

110LdU64(0)

111StLoc[12](loc9: u64)

112MoveLoc[4](loc1: u64)

113StLoc[23](loc20: u64)

B10:

114CopyLoc[12](loc9: u64)

115CopyLoc[23](loc20: u64)

116Lt

117BrFalse(168)

B11:

118CopyLoc[12](loc9: u64)

119Pop

120MutBorrowLoc[35](loc32: vector<ID>)

121VecPopBack(73)

122StLoc[15](loc12: ID)

123MutBorrowLoc[37](loc34: vector<u16>)

124VecPopBack(29)

125StLoc[38](loc35: u16)

126CopyLoc[10](loc7: &VecMap<ID, u64>)

127ImmBorrowLoc[15](loc12: ID)

128Call vec_map::try_get<ID, u64>(&VecMap<ID, u64>, &ID): Option<u64>

129StLoc[17](loc14: Option<u64>)

130ImmBorrowLoc[17](loc14: Option<u64>)

131Call option::is_some<u64>(&Option<u64>): bool

132BrFalse(138)

B12:

133Branch(134)

B13:

134MoveLoc[17](loc14: Option<u64>)

135Call option::destroy_some<u64>(Option<u64>): u64

136StLoc[5](loc2: u64)

137Branch(142)

B14:

138MoveLoc[17](loc14: Option<u64>)

139Call option::destroy_none<u64>(Option<u64>)

140LdU64(0)

141StLoc[5](loc2: u64)

B15:

142MoveLoc[5](loc2: u64)

143CopyLoc[20](loc17: u64)

144Call u64::min(u64, u64): u64

145StLoc[9](loc6: u64)

146CopyLoc[20](loc17: u64)

147MoveLoc[9](loc6: u64)

148Sub

149StLoc[25](loc22: u64)

150MoveLoc[38](loc35: u16)

151CastU128

152MoveLoc[25](loc22: u64)

153CastU128

154Mul

155StLoc[28](loc25: u128)

156MoveLoc[31](loc28: u128)

157CopyLoc[28](loc25: u128)

158Add

159StLoc[31](loc28: u128)

160MutBorrowLoc[27](loc24: vector<u128>)

161MoveLoc[28](loc25: u128)

162VecPushBack(80)

163MoveLoc[12](loc9: u64)

164LdU64(1)

165Add

166StLoc[12](loc9: u64)

167Branch(114)

B16:

168MoveLoc[10](loc7: &VecMap<ID, u64>)

169Pop

170MoveLoc[35](loc32: vector<ID>)

171VecUnpack(73, 0)

172MoveLoc[37](loc34: vector<u16>)

173VecUnpack(29, 0)

174MoveLoc[31](loc28: u128)

175LdU128(1)

176Call u128::max(u128, u128): u128

177StLoc[32](loc29: u128)

178ImmBorrowLoc[29](loc26: Balance<WAL>)

179Call balance::value<WAL>(&Balance<WAL>): u64

180CastU128

181StLoc[30](loc27: u128)

182MoveLoc[27](loc24: vector<u128>)

183StLoc[33](loc30: vector<u128>)

184VecPack(5, 0)

185StLoc[21](loc18: vector<Balance<WAL>>)

186MoveLoc[33](loc30: vector<u128>)

187StLoc[34](loc31: vector<u128>)

188MutBorrowLoc[34](loc31: vector<u128>)

189Call vector::reverse<u128>(&mut vector<u128>)

190ImmBorrowLoc[34](loc31: vector<u128>)

191VecLen(80)

192StLoc[3](loc0: u64)

193LdU64(0)

194StLoc[13](loc10: u64)

195MoveLoc[3](loc0: u64)

196StLoc[24](loc21: u64)

B17:

197CopyLoc[13](loc10: u64)

198CopyLoc[24](loc21: u64)

199Lt

200BrFalse(227)

B18:

201CopyLoc[13](loc10: u64)

202Pop

203MutBorrowLoc[34](loc31: vector<u128>)

204VecPopBack(80)

205StLoc[11](loc8: u128)

206MutBorrowLoc[21](loc18: vector<Balance<WAL>>)

207StLoc[7](loc4: &mut vector<Balance<WAL>>)

208MoveLoc[11](loc8: u128)

209StLoc[26](loc23: u128)

210MutBorrowLoc[29](loc26: Balance<WAL>)

211MoveLoc[26](loc23: u128)

212CopyLoc[30](loc27: u128)

213Mul

214CopyLoc[32](loc29: u128)

215Div

216CastU64

217Call balance::split<WAL>(&mut Balance<WAL>, u64): Balance<WAL>

218StLoc[6](loc3: Balance<WAL>)

219MoveLoc[7](loc4: &mut vector<Balance<WAL>>)

220MoveLoc[6](loc3: Balance<WAL>)

221VecPushBack(5)

222MoveLoc[13](loc10: u64)

223LdU64(1)

224Add

225StLoc[13](loc10: u64)

226Branch(197)

B19:

227MoveLoc[34](loc31: vector<u128>)

228VecUnpack(80, 0)

229MoveLoc[21](loc18: vector<Balance<WAL>>)

230StLoc[22](loc19: vector<Balance<WAL>>)

231MoveLoc[0](Arg0: &mut SystemStateInnerV1)

232MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

233LdU32(0)

234Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

235Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

236MoveLoc[29](loc26: Balance<WAL>)

237Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

238Pop

239MoveLoc[16](loc13: vector<ID>)

240MoveLoc[22](loc19: vector<Balance<WAL>>)

241Call vec_map::from_keys_values<ID, Balance<WAL>>(vector<ID>, vector<Balance<WAL>>): VecMap<ID, Balance<WAL>>

242Ret

}

public(friend) extract_burn_balance(Arg0: &mut SystemStateInnerV1): Balance<WAL> {

B0:

0MoveLoc[0](Arg0: &mut SystemStateInnerV1)

1MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

2Call storage_accounting::extract_burn_balance(&mut FutureAccountingRingBuffer): Balance<WAL>

3Ret

}

public(friend) reserve_space(Arg0: &mut SystemStateInnerV1, Arg1: u64, Arg2: u32, Arg3: &mut Coin<WAL>, Arg4: &mut TxContext): Storage {

L5: loc0: u32

L6: loc1: u32

B0:

0CopyLoc[2](Arg2: u32)

1LdU32(0)

2Gt

3BrFalse(5)

B1:

4Branch(13)

B2:

5MoveLoc[0](Arg0: &mut SystemStateInnerV1)

6Pop

7MoveLoc[3](Arg3: &mut Coin<WAL>)

8Pop

9MoveLoc[4](Arg4: &mut TxContext)

10Pop

11LdConst[4](u64: 2)

12Abort

B3:

13CopyLoc[2](Arg2: u32)

14CopyLoc[0](Arg0: &mut SystemStateInnerV1)

15ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

16Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

17Le

18BrFalse(20)

B4:

19Branch(28)

B5:

20MoveLoc[0](Arg0: &mut SystemStateInnerV1)

21Pop

22MoveLoc[3](Arg3: &mut Coin<WAL>)

23Pop

24MoveLoc[4](Arg4: &mut TxContext)

25Pop

26LdConst[4](u64: 2)

27Abort

B6:

28CopyLoc[0](Arg0: &mut SystemStateInnerV1)

29FreezeRef

30Call epoch(&SystemStateInnerV1): u32

31StLoc[6](loc1: u32)

32CopyLoc[6](loc1: u32)

33MoveLoc[2](Arg2: u32)

34Add

35StLoc[5](loc0: u32)

36MoveLoc[0](Arg0: &mut SystemStateInnerV1)

37MoveLoc[1](Arg1: u64)

38MoveLoc[6](loc1: u32)

39MoveLoc[5](loc0: u32)

40MoveLoc[3](Arg3: &mut Coin<WAL>)

41MoveLoc[4](Arg4: &mut TxContext)

42Call reserve_space_for_epochs(&mut SystemStateInnerV1, u64, u32, u32, &mut Coin<WAL>, &mut TxContext): Storage

43Ret

}

public(friend) reserve_space_for_epochs(Arg0: &mut SystemStateInnerV1, Arg1: u64, Arg2: u32, Arg3: u32, Arg4: &mut Coin<WAL>, Arg5: &mut TxContext): Storage {

L6: loc0: u32

L7: loc1: u32

L8: loc2: u32

L9: loc3: u32

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1FreezeRef

2Call epoch(&SystemStateInnerV1): u32

3StLoc[6](loc0: u32)

4MoveLoc[2](Arg2: u32)

5CopyLoc[6](loc0: u32)

6Call u32::max(u32, u32): u32

7StLoc[8](loc2: u32)

8CopyLoc[8](loc2: u32)

9CopyLoc[6](loc0: u32)

10Sub

11StLoc[9](loc3: u32)

12CopyLoc[3](Arg3: u32)

13MoveLoc[8](loc2: u32)

14Gt

15BrFalse(17)

B1:

16Branch(25)

B2:

17MoveLoc[0](Arg0: &mut SystemStateInnerV1)

18Pop

19MoveLoc[4](Arg4: &mut Coin<WAL>)

20Pop

21MoveLoc[5](Arg5: &mut TxContext)

22Pop

23LdConst[4](u64: 2)

24Abort

B3:

25MoveLoc[3](Arg3: u32)

26MoveLoc[6](loc0: u32)

27Sub

28StLoc[7](loc1: u32)

29CopyLoc[7](loc1: u32)

30CopyLoc[0](Arg0: &mut SystemStateInnerV1)

31ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

32Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

33Le

34BrFalse(36)

B4:

35Branch(44)

B5:

36MoveLoc[0](Arg0: &mut SystemStateInnerV1)

37Pop

38MoveLoc[4](Arg4: &mut Coin<WAL>)

39Pop

40MoveLoc[5](Arg5: &mut TxContext)

41Pop

42LdConst[4](u64: 2)

43Abort

B6:

44CopyLoc[0](Arg0: &mut SystemStateInnerV1)

45CopyLoc[1](Arg1: u64)

46CopyLoc[9](loc3: u32)

47CopyLoc[7](loc1: u32)

48MoveLoc[4](Arg4: &mut Coin<WAL>)

49Call process_storage_payments(&mut SystemStateInnerV1, u64, u32, u32, &mut Coin<WAL>)

50MoveLoc[0](Arg0: &mut SystemStateInnerV1)

51MoveLoc[1](Arg1: u64)

52MoveLoc[9](loc3: u32)

53MoveLoc[7](loc1: u32)

54LdTrue

55MoveLoc[5](Arg5: &mut TxContext)

56Call reserve_space_without_payment(&mut SystemStateInnerV1, u64, u32, u32, bool, &mut TxContext): Storage

57Ret

}

reserve_space_without_payment(Arg0: &mut SystemStateInnerV1, Arg1: u64, Arg2: u32, Arg3: u32, Arg4: bool, Arg5: &mut TxContext): Storage {

L6: loc0: bool

L7: loc1: u32

L8: loc2: u32

L9: loc3: u32

L10: loc4: u32

L11: loc5: u32

L12: loc6: u32

L13: loc7: u64

B0:

0CopyLoc[3](Arg3: u32)

1CopyLoc[2](Arg2: u32)

2Sub

3LdU32(0)

4Gt

5BrFalse(7)

B1:

6Branch(13)

B2:

7MoveLoc[0](Arg0: &mut SystemStateInnerV1)

8Pop

9MoveLoc[5](Arg5: &mut TxContext)

10Pop

11LdConst[4](u64: 2)

12Abort

B3:

13CopyLoc[3](Arg3: u32)

14CopyLoc[0](Arg0: &mut SystemStateInnerV1)

15ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

16Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

17Le

18BrFalse(20)

B4:

19Branch(26)

B5:

20MoveLoc[0](Arg0: &mut SystemStateInnerV1)

21Pop

22MoveLoc[5](Arg5: &mut TxContext)

23Pop

24LdConst[4](u64: 2)

25Abort

B6:

26CopyLoc[1](Arg1: u64)

27LdU64(0)

28Gt

29BrFalse(31)

B7:

30Branch(37)

B8:

31MoveLoc[0](Arg0: &mut SystemStateInnerV1)

32Pop

33MoveLoc[5](Arg5: &mut TxContext)

34Pop

35LdConst[13](u64: 11)

36Abort

B9:

37CopyLoc[2](Arg2: u32)

38StLoc[9](loc3: u32)

39CopyLoc[3](Arg3: u32)

40StLoc[12](loc6: u32)

B10:

41CopyLoc[9](loc3: u32)

42CopyLoc[12](loc6: u32)

43Lt

44BrFalse(89)

B11:

45CopyLoc[9](loc3: u32)

46StLoc[10](loc4: u32)

47CopyLoc[0](Arg0: &mut SystemStateInnerV1)

48MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

49CopyLoc[10](loc4: u32)

50Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

51CopyLoc[1](Arg1: u64)

52Call storage_accounting::increase_used_capacity(&mut FutureAccounting, u64): u64

53StLoc[13](loc7: u64)

54MoveLoc[10](loc4: u32)

55LdU32(0)

56Eq

57BrFalse(62)

B12:

58CopyLoc[13](loc7: u64)

59CopyLoc[0](Arg0: &mut SystemStateInnerV1)

60MutBorrowField[3](SystemStateInnerV1.used_capacity_size: u64)

61WriteRef

B13:

62CopyLoc[4](Arg4: bool)

63Not

64BrFalse(69)

B14:

65Branch(66)

B15:

66LdTrue

67StLoc[6](loc0: bool)

68Branch(75)

B16:

69MoveLoc[13](loc7: u64)

70CopyLoc[0](Arg0: &mut SystemStateInnerV1)

71ImmBorrowField[4](SystemStateInnerV1.total_capacity_size: u64)

72ReadRef

73Le

74StLoc[6](loc0: bool)

B17:

75MoveLoc[6](loc0: bool)

76BrFalse(78)

B18:

77Branch(84)

B19:

78MoveLoc[0](Arg0: &mut SystemStateInnerV1)

79Pop

80MoveLoc[5](Arg5: &mut TxContext)

81Pop

82LdConst[3](u64: 1)

83Abort

B20:

84MoveLoc[9](loc3: u32)

85LdU32(1)

86Add

87StLoc[9](loc3: u32)

88Branch(41)

B21:

89MoveLoc[0](Arg0: &mut SystemStateInnerV1)

90FreezeRef

91Call epoch(&SystemStateInnerV1): u32

92StLoc[7](loc1: u32)

93CopyLoc[7](loc1: u32)

94MoveLoc[2](Arg2: u32)

95Add

96StLoc[11](loc5: u32)

97MoveLoc[7](loc1: u32)

98MoveLoc[3](Arg3: u32)

99Add

100StLoc[8](loc2: u32)

101MoveLoc[11](loc5: u32)

102MoveLoc[8](loc2: u32)

103MoveLoc[1](Arg1: u64)

104MoveLoc[5](Arg5: &mut TxContext)

105Call storage_resource::create_storage(u32, u32, u64, &mut TxContext): Storage

106Ret

}

public(friend) invalidate_blob_id(Arg0: &SystemStateInnerV1, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>): u256 {

L4: loc0: u256

L5: loc1: CertifiedMessage

L6: loc2: u32

L7: loc3: CertifiedInvalidBlobId

B0:

0CopyLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

2MoveLoc[1](Arg1: vector<u8>)

3MoveLoc[2](Arg2: vector<u8>)

4MoveLoc[3](Arg3: vector<u8>)

5Call bls_aggregate::verify_one_correct_node_in_epoch(&BlsCommittee, vector<u8>, vector<u8>, vector<u8>): CertifiedMessage

6StLoc[5](loc1: CertifiedMessage)

7ImmBorrowLoc[5](loc1: CertifiedMessage)

8Call messages::cert_epoch(&CertifiedMessage): u32

9StLoc[6](loc2: u32)

10MoveLoc[5](loc1: CertifiedMessage)

11Call messages::invalid_blob_id_message(CertifiedMessage): CertifiedInvalidBlobId

12StLoc[7](loc3: CertifiedInvalidBlobId)

13ImmBorrowLoc[7](loc3: CertifiedInvalidBlobId)

14Call messages::invalid_blob_id(&CertifiedInvalidBlobId): u256

15StLoc[4](loc0: u256)

16CopyLoc[6](loc2: u32)

17MoveLoc[0](Arg0: &SystemStateInnerV1)

18Call epoch(&SystemStateInnerV1): u32

19Eq

20BrFalse(22)

B1:

21Branch(24)

B2:

22LdConst[5](u64: 3)

23Abort

B3:

24MoveLoc[6](loc2: u32)

25CopyLoc[4](loc0: u256)

26Call events::emit_invalid_blob_id(u32, u256)

27MoveLoc[4](loc0: u256)

28Ret

}

public(friend) register_blob(Arg0: &mut SystemStateInnerV1, Arg1: Storage, Arg2: u256, Arg3: u256, Arg4: u64, Arg5: u8, Arg6: bool, Arg7: &mut Coin<WAL>, Arg8: &mut TxContext): Blob {

L9: loc0: Blob

L10: loc1: Balance<WAL>

L11: loc2: u64

B0:

0MoveLoc[1](Arg1: Storage)

1MoveLoc[2](Arg2: u256)

2MoveLoc[3](Arg3: u256)

3MoveLoc[4](Arg4: u64)

4MoveLoc[5](Arg5: u8)

5MoveLoc[6](Arg6: bool)

6CopyLoc[0](Arg0: &mut SystemStateInnerV1)

7FreezeRef

8Call epoch(&SystemStateInnerV1): u32

9CopyLoc[0](Arg0: &mut SystemStateInnerV1)

10FreezeRef

11Call n_shards(&SystemStateInnerV1): u16

12MoveLoc[8](Arg8: &mut TxContext)

13Call blob::new(Storage, u256, u256, u64, u8, bool, u32, u16, &mut TxContext): Blob

14StLoc[9](loc0: Blob)

15CopyLoc[0](Arg0: &mut SystemStateInnerV1)

16FreezeRef

17ImmBorrowLoc[9](loc0: Blob)

18CopyLoc[0](Arg0: &mut SystemStateInnerV1)

19FreezeRef

20Call n_shards(&SystemStateInnerV1): u16

21Call blob::encoded_size(&Blob, u16): u64

22Call write_price(&SystemStateInnerV1, u64): u64

23StLoc[11](loc2: u64)

24MoveLoc[7](Arg7: &mut Coin<WAL>)

25Call coin::balance_mut<WAL>(&mut Coin<WAL>): &mut Balance<WAL>

26MoveLoc[11](loc2: u64)

27Call balance::split<WAL>(&mut Balance<WAL>, u64): Balance<WAL>

28StLoc[10](loc1: Balance<WAL>)

29MoveLoc[0](Arg0: &mut SystemStateInnerV1)

30MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

31LdU32(0)

32Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

33Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

34MoveLoc[10](loc1: Balance<WAL>)

35Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

36Pop

37MoveLoc[9](loc0: Blob)

38Ret

}

public(friend) certify_blob(Arg0: &SystemStateInnerV1, Arg1: &mut Blob, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>) {

L5: loc0: CertifiedBlobMessage

L6: loc1: CertifiedMessage

B0:

0CopyLoc[0](Arg0: &SystemStateInnerV1)

1Call committee(&SystemStateInnerV1): &BlsCommittee

2MoveLoc[2](Arg2: vector<u8>)

3MoveLoc[3](Arg3: vector<u8>)

4MoveLoc[4](Arg4: vector<u8>)

5Call bls_aggregate::verify_quorum_in_epoch(&BlsCommittee, vector<u8>, vector<u8>, vector<u8>): CertifiedMessage

6StLoc[6](loc1: CertifiedMessage)

7ImmBorrowLoc[6](loc1: CertifiedMessage)

8Call messages::cert_epoch(&CertifiedMessage): u32

9CopyLoc[0](Arg0: &SystemStateInnerV1)

10Call epoch(&SystemStateInnerV1): u32

11Eq

12BrFalse(14)

B1:

13Branch(20)

B2:

14MoveLoc[0](Arg0: &SystemStateInnerV1)

15Pop

16MoveLoc[1](Arg1: &mut Blob)

17Pop

18LdConst[5](u64: 3)

19Abort

B3:

20MoveLoc[6](loc1: CertifiedMessage)

21Call messages::certify_blob_message(CertifiedMessage): CertifiedBlobMessage

22StLoc[5](loc0: CertifiedBlobMessage)

23MoveLoc[1](Arg1: &mut Blob)

24MoveLoc[0](Arg0: &SystemStateInnerV1)

25Call epoch(&SystemStateInnerV1): u32

26MoveLoc[5](loc0: CertifiedBlobMessage)

27Call blob::certify_with_certified_msg(&mut Blob, u32, CertifiedBlobMessage)

28Ret

}

public(friend) delete_blob(Arg0: &SystemStateInnerV1, Arg1: Blob): Storage {

B0:

0MoveLoc[1](Arg1: Blob)

1MoveLoc[0](Arg0: &SystemStateInnerV1)

2Call epoch(&SystemStateInnerV1): u32

3Call blob::delete(Blob, u32): Storage

4Ret

}

public(friend) extend_blob_with_resource(Arg0: &SystemStateInnerV1, Arg1: &mut Blob, Arg2: Storage) {

B0:

0MoveLoc[1](Arg1: &mut Blob)

1MoveLoc[2](Arg2: Storage)

2MoveLoc[0](Arg0: &SystemStateInnerV1)

3Call epoch(&SystemStateInnerV1): u32

4Call blob::extend_with_resource(&mut Blob, Storage, u32)

5Ret

}

public(friend) extend_blob(Arg0: &mut SystemStateInnerV1, Arg1: &mut Blob, Arg2: u32, Arg3: &mut Coin<WAL>) {

L4: loc0: u32

L5: loc1: u32

L6: loc2: u32

L7: loc3: u32

L8: loc4: u32

L9: loc5: u64

B0:

0CopyLoc[1](Arg1: &mut Blob)

1FreezeRef

2CopyLoc[0](Arg0: &mut SystemStateInnerV1)

3FreezeRef

4Call epoch(&SystemStateInnerV1): u32

5Call blob::assert_certified_not_expired(&Blob, u32)

6CopyLoc[1](Arg1: &mut Blob)

7FreezeRef

8Call blob::storage(&Blob): &Storage

9Call storage_resource::end_epoch(&Storage): u32

10CopyLoc[0](Arg0: &mut SystemStateInnerV1)

11FreezeRef

12Call epoch(&SystemStateInnerV1): u32

13Sub

14StLoc[7](loc3: u32)

15CopyLoc[7](loc3: u32)

16CopyLoc[2](Arg2: u32)

17Add

18StLoc[4](loc0: u32)

19CopyLoc[2](Arg2: u32)

20LdU32(0)

21Gt

22BrFalse(24)

B1:

23Branch(32)

B2:

24MoveLoc[0](Arg0: &mut SystemStateInnerV1)

25Pop

26MoveLoc[3](Arg3: &mut Coin<WAL>)

27Pop

28MoveLoc[1](Arg1: &mut Blob)

29Pop

30LdConst[4](u64: 2)

31Abort

B3:

32CopyLoc[4](loc0: u32)

33CopyLoc[0](Arg0: &mut SystemStateInnerV1)

34ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

35Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

36Le

37BrFalse(39)

B4:

38Branch(47)

B5:

39MoveLoc[0](Arg0: &mut SystemStateInnerV1)

40Pop

41MoveLoc[3](Arg3: &mut Coin<WAL>)

42Pop

43MoveLoc[1](Arg1: &mut Blob)

44Pop

45LdConst[4](u64: 2)

46Abort

B6:

47CopyLoc[1](Arg1: &mut Blob)

48FreezeRef

49Call blob::storage(&Blob): &Storage

50Call storage_resource::size(&Storage): u64

51StLoc[9](loc5: u64)

52CopyLoc[0](Arg0: &mut SystemStateInnerV1)

53CopyLoc[9](loc5: u64)

54CopyLoc[7](loc3: u32)

55CopyLoc[4](loc0: u32)

56MoveLoc[3](Arg3: &mut Coin<WAL>)

57Call process_storage_payments(&mut SystemStateInnerV1, u64, u32, u32, &mut Coin<WAL>)

58MoveLoc[7](loc3: u32)

59StLoc[5](loc1: u32)

60MoveLoc[4](loc0: u32)

61StLoc[8](loc4: u32)

B7:

62CopyLoc[5](loc1: u32)

63CopyLoc[8](loc4: u32)

64Lt

65BrFalse(91)

B8:

66CopyLoc[5](loc1: u32)

67StLoc[6](loc2: u32)

68CopyLoc[0](Arg0: &mut SystemStateInnerV1)

69MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

70MoveLoc[6](loc2: u32)

71Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

72CopyLoc[9](loc5: u64)

73Call storage_accounting::increase_used_capacity(&mut FutureAccounting, u64): u64

74CopyLoc[0](Arg0: &mut SystemStateInnerV1)

75ImmBorrowField[4](SystemStateInnerV1.total_capacity_size: u64)

76ReadRef

77Le

78BrFalse(80)

B9:

79Branch(86)

B10:

80MoveLoc[0](Arg0: &mut SystemStateInnerV1)

81Pop

82MoveLoc[1](Arg1: &mut Blob)

83Pop

84LdConst[3](u64: 1)

85Abort

B11:

86MoveLoc[5](loc1: u32)

87LdU32(1)

88Add

89StLoc[5](loc1: u32)

90Branch(62)

B12:

91MoveLoc[0](Arg0: &mut SystemStateInnerV1)

92Pop

93CopyLoc[1](Arg1: &mut Blob)

94Call blob::storage_mut(&mut Blob): &mut Storage

95MoveLoc[2](Arg2: u32)

96Call storage_resource::extend_end_epoch(&mut Storage, u32)

97MoveLoc[1](Arg1: &mut Blob)

98FreezeRef

99LdTrue

100Call blob::emit_certified(&Blob, bool)

101Ret

}

process_storage_payments(Arg0: &mut SystemStateInnerV1, Arg1: u64, Arg2: u32, Arg3: u32, Arg4: &mut Coin<WAL>) {

L5: loc0: &mut Balance<WAL>

L6: loc1: Balance<WAL>

L7: loc2: u32

L8: loc3: u32

L9: loc4: u64

L10: loc5: u32

L11: loc6: u64

B0:

0MoveLoc[1](Arg1: u64)

1LdConst[1](u64: 1048..)

2Call u64::div_ceil(u64, u64): u64

3StLoc[11](loc6: u64)

4CopyLoc[0](Arg0: &mut SystemStateInnerV1)

5ImmBorrowField[6](SystemStateInnerV1.storage_price_per_unit_size: u64)

6ReadRef

7MoveLoc[11](loc6: u64)

8Mul

9StLoc[9](loc4: u64)

10MoveLoc[4](Arg4: &mut Coin<WAL>)

11Call coin::balance_mut<WAL>(&mut Coin<WAL>): &mut Balance<WAL>

12StLoc[5](loc0: &mut Balance<WAL>)

13MoveLoc[2](Arg2: u32)

14StLoc[7](loc2: u32)

15MoveLoc[3](Arg3: u32)

16StLoc[10](loc5: u32)

B1:

17CopyLoc[7](loc2: u32)

18CopyLoc[10](loc5: u32)

19Lt

20BrFalse(40)

B2:

21CopyLoc[7](loc2: u32)

22StLoc[8](loc3: u32)

23CopyLoc[5](loc0: &mut Balance<WAL>)

24CopyLoc[9](loc4: u64)

25Call balance::split<WAL>(&mut Balance<WAL>, u64): Balance<WAL>

26StLoc[6](loc1: Balance<WAL>)

27CopyLoc[0](Arg0: &mut SystemStateInnerV1)

28MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

29MoveLoc[8](loc3: u32)

30Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

31Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

32MoveLoc[6](loc1: Balance<WAL>)

33Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

34Pop

35MoveLoc[7](loc2: u32)

36LdU32(1)

37Add

38StLoc[7](loc2: u32)

39Branch(17)

B3:

40MoveLoc[0](Arg0: &mut SystemStateInnerV1)

41Pop

42MoveLoc[5](loc0: &mut Balance<WAL>)

43Pop

44Ret

}

public(friend) certify_event_blob(Arg0: &mut SystemStateInnerV1, Arg1: &mut StorageNodeCap, Arg2: u256, Arg3: u256, Arg4: u64, Arg5: u8, Arg6: u64, Arg7: u32, Arg8: &mut TxContext) {

L9: loc0: ID

L10: loc1: &BlsCommittee

L11: loc2: bool

L12: loc3: bool

L13: loc4: ID

L14: loc5: &BlsCommittee

L15: loc6: u16

L16: loc7: EventBlobAttestation

L17: loc8: EventBlobAttestation

L18: loc9: Blob

L19: loc10: CertifiedBlobMessage

L20: loc11: u32

L21: loc12: Option<u64>

L22: loc13: u64

L23: loc14: u16

L24: loc15: Option<EventBlobAttestation>

L25: loc16: u16

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1FreezeRef

2Call committee(&SystemStateInnerV1): &BlsCommittee

3StLoc[10](loc1: &BlsCommittee)

4CopyLoc[1](Arg1: &mut StorageNodeCap)

5FreezeRef

6Call storage_node::node_id(&StorageNodeCap): ID

7StLoc[9](loc0: ID)

8MoveLoc[10](loc1: &BlsCommittee)

9ImmBorrowLoc[9](loc0: ID)

10Call bls_aggregate::contains(&BlsCommittee, &ID): bool

11BrFalse(13)

B1:

12Branch(21)

B2:

13MoveLoc[0](Arg0: &mut SystemStateInnerV1)

14Pop

15MoveLoc[8](Arg8: &mut TxContext)

16Pop

17MoveLoc[1](Arg1: &mut StorageNodeCap)

18Pop

19LdConst[10](u64: 8)

20Abort

B3:

21CopyLoc[7](Arg7: u32)

22CopyLoc[0](Arg0: &mut SystemStateInnerV1)

23FreezeRef

24Call epoch(&SystemStateInnerV1): u32

25Eq

26BrFalse(28)

B4:

27Branch(36)

B5:

28MoveLoc[0](Arg0: &mut SystemStateInnerV1)

29Pop

30MoveLoc[8](Arg8: &mut TxContext)

31Pop

32MoveLoc[1](Arg1: &mut StorageNodeCap)

33Pop

34LdConst[5](u64: 3)

35Abort

B6:

36CopyLoc[1](Arg1: &mut StorageNodeCap)

37Call storage_node::last_event_blob_attestation(&mut StorageNodeCap): Option<EventBlobAttestation>

38StLoc[24](loc15: Option<EventBlobAttestation>)

39ImmBorrowLoc[24](loc15: Option<EventBlobAttestation>)

40Call option::is_some<EventBlobAttestation>(&Option<EventBlobAttestation>): bool

41BrFalse(123)

B7:

42MoveLoc[24](loc15: Option<EventBlobAttestation>)

43Call option::destroy_some<EventBlobAttestation>(Option<EventBlobAttestation>): EventBlobAttestation

44StLoc[16](loc7: EventBlobAttestation)

45ImmBorrowLoc[16](loc7: EventBlobAttestation)

46Call event_blob::last_attested_event_blob_epoch(&EventBlobAttestation): u32

47CopyLoc[0](Arg0: &mut SystemStateInnerV1)

48FreezeRef

49Call epoch(&SystemStateInnerV1): u32

50Lt

51BrFalse(55)

B8:

52LdTrue

53StLoc[11](loc2: bool)

54Branch(60)

B9:

55CopyLoc[6](Arg6: u64)

56ImmBorrowLoc[16](loc7: EventBlobAttestation)

57Call event_blob::last_attested_event_blob_checkpoint_seq_num(&EventBlobAttestation): u64

58Gt

59StLoc[11](loc2: bool)

B10:

60MoveLoc[11](loc2: bool)

61BrFalse(63)

B11:

62Branch(71)

B12:

63MoveLoc[0](Arg0: &mut SystemStateInnerV1)

64Pop

65MoveLoc[8](Arg8: &mut TxContext)

66Pop

67MoveLoc[1](Arg1: &mut StorageNodeCap)

68Pop

69LdConst[9](u64: 7)

70Abort

B13:

71CopyLoc[0](Arg0: &mut SystemStateInnerV1)

72ImmBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

73Call event_blob::get_latest_certified_checkpoint_sequence_number(&EventBlobCertificationState): Option<u64>

74StLoc[21](loc12: Option<u64>)

75ImmBorrowLoc[21](loc12: Option<u64>)

76Call option::is_some<u64>(&Option<u64>): bool

77BrFalse(107)

B14:

78MoveLoc[21](loc12: Option<u64>)

79Call option::destroy_some<u64>(Option<u64>): u64

80StLoc[22](loc13: u64)

81ImmBorrowLoc[16](loc7: EventBlobAttestation)

82Call event_blob::last_attested_event_blob_epoch(&EventBlobAttestation): u32

83CopyLoc[0](Arg0: &mut SystemStateInnerV1)

84FreezeRef

85Call epoch(&SystemStateInnerV1): u32

86Lt

87BrFalse(91)

B15:

88LdTrue

89StLoc[12](loc3: bool)

90Branch(96)

B16:

91ImmBorrowLoc[16](loc7: EventBlobAttestation)

92Call event_blob::last_attested_event_blob_checkpoint_seq_num(&EventBlobAttestation): u64

93MoveLoc[22](loc13: u64)

94Le

95StLoc[12](loc3: bool)

B17:

96MoveLoc[12](loc3: bool)

97BrFalse(99)

B18:

98Branch(125)

B19:

99MoveLoc[0](Arg0: &mut SystemStateInnerV1)

100Pop

101MoveLoc[8](Arg8: &mut TxContext)

102Pop

103MoveLoc[1](Arg1: &mut StorageNodeCap)

104Pop

105LdConst[8](u64: 6)

106Abort

B20:

107ImmBorrowLoc[16](loc7: EventBlobAttestation)

108Call event_blob::last_attested_event_blob_epoch(&EventBlobAttestation): u32

109CopyLoc[0](Arg0: &mut SystemStateInnerV1)

110FreezeRef

111Call epoch(&SystemStateInnerV1): u32

112Lt

113BrFalse(115)

B21:

114Branch(125)

B22:

115MoveLoc[0](Arg0: &mut SystemStateInnerV1)

116Pop

117MoveLoc[8](Arg8: &mut TxContext)

118Pop

119MoveLoc[1](Arg1: &mut StorageNodeCap)

120Pop

121LdConst[8](u64: 6)

122Abort

B23:

123MoveLoc[24](loc15: Option<EventBlobAttestation>)

124Call option::destroy_none<EventBlobAttestation>(Option<EventBlobAttestation>)

B24:

125CopyLoc[6](Arg6: u64)

126MoveLoc[7](Arg7: u32)

127Call event_blob::new_attestation(u64, u32): EventBlobAttestation

128StLoc[17](loc8: EventBlobAttestation)

129CopyLoc[1](Arg1: &mut StorageNodeCap)

130MoveLoc[17](loc8: EventBlobAttestation)

131Call storage_node::set_last_event_blob_attestation(&mut StorageNodeCap, EventBlobAttestation)

132CopyLoc[0](Arg0: &mut SystemStateInnerV1)

133ImmBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

134CopyLoc[6](Arg6: u64)

135Call event_blob::is_blob_already_certified(&EventBlobCertificationState, u64): bool

136BrFalse(144)

B25:

137MoveLoc[0](Arg0: &mut SystemStateInnerV1)

138Pop

139MoveLoc[8](Arg8: &mut TxContext)

140Pop

141MoveLoc[1](Arg1: &mut StorageNodeCap)

142Pop

143Ret

B26:

144CopyLoc[0](Arg0: &mut SystemStateInnerV1)

145MutBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

146CopyLoc[2](Arg2: u256)

147CopyLoc[6](Arg6: u64)

148Call event_blob::start_tracking_blob(&mut EventBlobCertificationState, u256, u64)

149CopyLoc[0](Arg0: &mut SystemStateInnerV1)

150FreezeRef

151Call committee(&SystemStateInnerV1): &BlsCommittee

152StLoc[14](loc5: &BlsCommittee)

153MoveLoc[1](Arg1: &mut StorageNodeCap)

154FreezeRef

155Call storage_node::node_id(&StorageNodeCap): ID

156StLoc[13](loc4: ID)

157MoveLoc[14](loc5: &BlsCommittee)

158ImmBorrowLoc[13](loc4: ID)

159Call bls_aggregate::get_member_weight(&BlsCommittee, &ID): u16

160StLoc[25](loc16: u16)

161CopyLoc[0](Arg0: &mut SystemStateInnerV1)

162MutBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

163CopyLoc[2](Arg2: u256)

164CopyLoc[6](Arg6: u64)

165MoveLoc[25](loc16: u16)

166Call event_blob::update_aggregate_weight(&mut EventBlobCertificationState, u256, u64, u16): u16

167StLoc[15](loc6: u16)

168CopyLoc[0](Arg0: &mut SystemStateInnerV1)

169FreezeRef

170Call committee(&SystemStateInnerV1): &BlsCommittee

171MoveLoc[15](loc6: u16)

172Call bls_aggregate::is_quorum(&BlsCommittee, u16): bool

173Not

174BrFalse(180)

B27:

175MoveLoc[0](Arg0: &mut SystemStateInnerV1)

176Pop

177MoveLoc[8](Arg8: &mut TxContext)

178Pop

179Ret

B28:

180CopyLoc[0](Arg0: &mut SystemStateInnerV1)

181FreezeRef

182Call n_shards(&SystemStateInnerV1): u16

183StLoc[23](loc14: u16)

184CopyLoc[0](Arg0: &mut SystemStateInnerV1)

185ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

186Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

187StLoc[20](loc11: u32)

188CopyLoc[0](Arg0: &mut SystemStateInnerV1)

189CopyLoc[4](Arg4: u64)

190CopyLoc[5](Arg5: u8)

191MoveLoc[23](loc14: u16)

192Call encoding::encoded_blob_length(u64, u8, u16): u64

193LdU32(0)

194MoveLoc[20](loc11: u32)

195LdFalse

196CopyLoc[8](Arg8: &mut TxContext)

197Call reserve_space_without_payment(&mut SystemStateInnerV1, u64, u32, u32, bool, &mut TxContext): Storage

198CopyLoc[2](Arg2: u256)

199MoveLoc[3](Arg3: u256)

200MoveLoc[4](Arg4: u64)

201MoveLoc[5](Arg5: u8)

202LdFalse

203CopyLoc[0](Arg0: &mut SystemStateInnerV1)

204FreezeRef

205Call epoch(&SystemStateInnerV1): u32

206CopyLoc[0](Arg0: &mut SystemStateInnerV1)

207FreezeRef

208Call n_shards(&SystemStateInnerV1): u16

209MoveLoc[8](Arg8: &mut TxContext)

210Call blob::new(Storage, u256, u256, u64, u8, bool, u32, u16, &mut TxContext): Blob

211StLoc[18](loc9: Blob)

212CopyLoc[2](Arg2: u256)

213Call messages::certified_system_blob_message(u256): CertifiedBlobMessage

214StLoc[19](loc10: CertifiedBlobMessage)

215MutBorrowLoc[18](loc9: Blob)

216CopyLoc[0](Arg0: &mut SystemStateInnerV1)

217FreezeRef

218Call epoch(&SystemStateInnerV1): u32

219MoveLoc[19](loc10: CertifiedBlobMessage)

220Call blob::certify_with_certified_msg(&mut Blob, u32, CertifiedBlobMessage)

221CopyLoc[0](Arg0: &mut SystemStateInnerV1)

222MutBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

223MoveLoc[6](Arg6: u64)

224MoveLoc[2](Arg2: u256)

225Call event_blob::update_latest_certified_event_blob(&mut EventBlobCertificationState, u64, u256)

226MoveLoc[0](Arg0: &mut SystemStateInnerV1)

227MutBorrowField[2](SystemStateInnerV1.event_blob_certification_state: EventBlobCertificationState)

228Call event_blob::reset(&mut EventBlobCertificationState)

229MoveLoc[18](loc9: Blob)

230Call blob::burn(Blob)

231Ret

}

public(friend) certify_snapshot_blob(Arg0: &mut SystemStateInnerV1, Arg1: &mut SnapshotBlobCertificationState, Arg2: &StorageNodeCap, Arg3: u256, Arg4: u256, Arg5: u64, Arg6: u8, Arg7: u32, Arg8: &mut TxContext) {

L9: loc0: ID

L10: loc1: &BlsCommittee

L11: loc2: ID

L12: loc3: &SnapshotBlobCertificationState

L13: loc4: ID

L14: loc5: &BlsCommittee

L15: loc6: u16

L16: loc7: Blob

L17: loc8: CertifiedBlobMessage

L18: loc9: u32

L19: loc10: u16

L20: loc11: u16

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1FreezeRef

2Call committee(&SystemStateInnerV1): &BlsCommittee

3StLoc[10](loc1: &BlsCommittee)

4CopyLoc[2](Arg2: &StorageNodeCap)

5Call storage_node::node_id(&StorageNodeCap): ID

6StLoc[9](loc0: ID)

7MoveLoc[10](loc1: &BlsCommittee)

8ImmBorrowLoc[9](loc0: ID)

9Call bls_aggregate::contains(&BlsCommittee, &ID): bool

10BrFalse(12)

B1:

11Branch(22)

B2:

12MoveLoc[1](Arg1: &mut SnapshotBlobCertificationState)

13Pop

14MoveLoc[0](Arg0: &mut SystemStateInnerV1)

15Pop

16MoveLoc[8](Arg8: &mut TxContext)

17Pop

18MoveLoc[2](Arg2: &StorageNodeCap)

19Pop

20LdConst[10](u64: 8)

21Abort

B3:

22CopyLoc[7](Arg7: u32)

23CopyLoc[0](Arg0: &mut SystemStateInnerV1)

24FreezeRef

25Call epoch(&SystemStateInnerV1): u32

26Eq

27BrFalse(29)

B4:

28Branch(39)

B5:

29MoveLoc[1](Arg1: &mut SnapshotBlobCertificationState)

30Pop

31MoveLoc[0](Arg0: &mut SystemStateInnerV1)

32Pop

33MoveLoc[8](Arg8: &mut TxContext)

34Pop

35MoveLoc[2](Arg2: &StorageNodeCap)

36Pop

37LdConst[5](u64: 3)

38Abort

B6:

39CopyLoc[1](Arg1: &mut SnapshotBlobCertificationState)

40CopyLoc[7](Arg7: u32)

41Call snapshot_blob::advance_tally_epoch(&mut SnapshotBlobCertificationState, u32)

42CopyLoc[1](Arg1: &mut SnapshotBlobCertificationState)

43FreezeRef

44CopyLoc[7](Arg7: u32)

45Call snapshot_blob::is_epoch_certified(&SnapshotBlobCertificationState, u32): bool

46BrFalse(56)

B7:

47MoveLoc[1](Arg1: &mut SnapshotBlobCertificationState)

48Pop

49MoveLoc[0](Arg0: &mut SystemStateInnerV1)

50Pop

51MoveLoc[8](Arg8: &mut TxContext)

52Pop

53MoveLoc[2](Arg2: &StorageNodeCap)

54Pop

55Ret

B8:

56CopyLoc[1](Arg1: &mut SnapshotBlobCertificationState)

57FreezeRef

58StLoc[12](loc3: &SnapshotBlobCertificationState)

59CopyLoc[2](Arg2: &StorageNodeCap)

60Call storage_node::node_id(&StorageNodeCap): ID

61StLoc[11](loc2: ID)

62MoveLoc[12](loc3: &SnapshotBlobCertificationState)

63ImmBorrowLoc[11](loc2: ID)

64Call snapshot_blob::has_attested(&SnapshotBlobCertificationState, &ID): bool

65Not

66BrFalse(68)

B9:

67Branch(78)

B10:

68MoveLoc[1](Arg1: &mut SnapshotBlobCertificationState)

69Pop

70MoveLoc[0](Arg0: &mut SystemStateInnerV1)

71Pop

72MoveLoc[8](Arg8: &mut TxContext)

73Pop

74MoveLoc[2](Arg2: &StorageNodeCap)

75Pop

76LdConst[9](u64: 7)

77Abort

B11:

78CopyLoc[1](Arg1: &mut SnapshotBlobCertificationState)

79CopyLoc[2](Arg2: &StorageNodeCap)

80Call storage_node::node_id(&StorageNodeCap): ID

81Call snapshot_blob::record_attestation(&mut SnapshotBlobCertificationState, ID)

82CopyLoc[0](Arg0: &mut SystemStateInnerV1)

83FreezeRef

84Call committee(&SystemStateInnerV1): &BlsCommittee

85StLoc[14](loc5: &BlsCommittee)

86MoveLoc[2](Arg2: &StorageNodeCap)

87Call storage_node::node_id(&StorageNodeCap): ID

88StLoc[13](loc4: ID)

89MoveLoc[14](loc5: &BlsCommittee)

90ImmBorrowLoc[13](loc4: ID)

91Call bls_aggregate::get_member_weight(&BlsCommittee, &ID): u16

92StLoc[20](loc11: u16)

93CopyLoc[1](Arg1: &mut SnapshotBlobCertificationState)

94CopyLoc[3](Arg3: u256)

95MoveLoc[20](loc11: u16)

96Call snapshot_blob::add_aggregate_weight(&mut SnapshotBlobCertificationState, u256, u16): u16

97StLoc[15](loc6: u16)

98CopyLoc[0](Arg0: &mut SystemStateInnerV1)

99FreezeRef

100Call committee(&SystemStateInnerV1): &BlsCommittee

101MoveLoc[15](loc6: u16)

102Call bls_aggregate::is_quorum(&BlsCommittee, u16): bool

103Not

104BrFalse(112)

B12:

105MoveLoc[1](Arg1: &mut SnapshotBlobCertificationState)

106Pop

107MoveLoc[0](Arg0: &mut SystemStateInnerV1)

108Pop

109MoveLoc[8](Arg8: &mut TxContext)

110Pop

111Ret

B13:

112CopyLoc[0](Arg0: &mut SystemStateInnerV1)

113FreezeRef

114Call n_shards(&SystemStateInnerV1): u16

115StLoc[19](loc10: u16)

116CopyLoc[0](Arg0: &mut SystemStateInnerV1)

117ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

118Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

119StLoc[18](loc9: u32)

120CopyLoc[0](Arg0: &mut SystemStateInnerV1)

121CopyLoc[5](Arg5: u64)

122CopyLoc[6](Arg6: u8)

123MoveLoc[19](loc10: u16)

124Call encoding::encoded_blob_length(u64, u8, u16): u64

125LdU32(0)

126MoveLoc[18](loc9: u32)

127LdFalse

128CopyLoc[8](Arg8: &mut TxContext)

129Call reserve_space_without_payment(&mut SystemStateInnerV1, u64, u32, u32, bool, &mut TxContext): Storage

130CopyLoc[3](Arg3: u256)

131MoveLoc[4](Arg4: u256)

132MoveLoc[5](Arg5: u64)

133MoveLoc[6](Arg6: u8)

134LdFalse

135CopyLoc[0](Arg0: &mut SystemStateInnerV1)

136FreezeRef

137Call epoch(&SystemStateInnerV1): u32

138CopyLoc[0](Arg0: &mut SystemStateInnerV1)

139FreezeRef

140Call n_shards(&SystemStateInnerV1): u16

141MoveLoc[8](Arg8: &mut TxContext)

142Call blob::new(Storage, u256, u256, u64, u8, bool, u32, u16, &mut TxContext): Blob

143StLoc[16](loc7: Blob)

144CopyLoc[3](Arg3: u256)

145Call messages::certified_system_blob_message(u256): CertifiedBlobMessage

146StLoc[17](loc8: CertifiedBlobMessage)

147MutBorrowLoc[16](loc7: Blob)

148MoveLoc[0](Arg0: &mut SystemStateInnerV1)

149FreezeRef

150Call epoch(&SystemStateInnerV1): u32

151MoveLoc[17](loc8: CertifiedBlobMessage)

152Call blob::certify_with_certified_msg(&mut Blob, u32, CertifiedBlobMessage)

153MoveLoc[1](Arg1: &mut SnapshotBlobCertificationState)

154MoveLoc[7](Arg7: u32)

155MoveLoc[3](Arg3: u256)

156ImmBorrowLoc[16](loc7: Blob)

157Call blob::storage(&Blob): &Storage

158Call storage_resource::end_epoch(&Storage): u32

159Call snapshot_blob::certify(&mut SnapshotBlobCertificationState, u32, u256, u32)

160MoveLoc[16](loc7: Blob)

161Call blob::burn(Blob)

162Ret

}

public(friend) add_subsidy(Arg0: &mut SystemStateInnerV1, Arg1: Coin<WAL>, Arg2: u32) {

L3: loc0: u32

L4: loc1: u32

L5: loc2: u32

L6: loc3: u64

L7: loc4: u32

L8: loc5: Balance<WAL>

B0:

0CopyLoc[2](Arg2: u32)

1LdU32(0)

2Gt

3BrFalse(5)

B1:

4Branch(9)

B2:

5MoveLoc[0](Arg0: &mut SystemStateInnerV1)

6Pop

7LdConst[4](u64: 2)

8Abort

B3:

9CopyLoc[2](Arg2: u32)

10CopyLoc[0](Arg0: &mut SystemStateInnerV1)

11ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

12Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

13Le

14BrFalse(16)

B4:

15Branch(20)

B5:

16MoveLoc[0](Arg0: &mut SystemStateInnerV1)

17Pop

18LdConst[4](u64: 2)

19Abort

B6:

20MoveLoc[1](Arg1: Coin<WAL>)

21Call coin::into_balance<WAL>(Coin<WAL>): Balance<WAL>

22StLoc[8](loc5: Balance<WAL>)

23ImmBorrowLoc[8](loc5: Balance<WAL>)

24Call balance::value<WAL>(&Balance<WAL>): u64

25CopyLoc[2](Arg2: u32)

26CastU64

27Div

28StLoc[6](loc3: u64)

29ImmBorrowLoc[8](loc5: Balance<WAL>)

30Call balance::value<WAL>(&Balance<WAL>): u64

31CopyLoc[2](Arg2: u32)

32CastU64

33Mod

34Pop

35MoveLoc[2](Arg2: u32)

36StLoc[3](loc0: u32)

37LdU32(0)

38StLoc[4](loc1: u32)

39MoveLoc[3](loc0: u32)

40StLoc[7](loc4: u32)

B7:

41CopyLoc[4](loc1: u32)

42CopyLoc[7](loc4: u32)

43Lt

44BrFalse(62)

B8:

45CopyLoc[4](loc1: u32)

46StLoc[5](loc2: u32)

47CopyLoc[0](Arg0: &mut SystemStateInnerV1)

48MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

49MoveLoc[5](loc2: u32)

50Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

51Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

52MutBorrowLoc[8](loc5: Balance<WAL>)

53CopyLoc[6](loc3: u64)

54Call balance::split<WAL>(&mut Balance<WAL>, u64): Balance<WAL>

55Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

56Pop

57MoveLoc[4](loc1: u32)

58LdU32(1)

59Add

60StLoc[4](loc1: u32)

61Branch(41)

B9:

62MoveLoc[0](Arg0: &mut SystemStateInnerV1)

63MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

64LdU32(0)

65Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

66Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

67MoveLoc[8](loc5: Balance<WAL>)

68Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

69Pop

70Ret

}

public(friend) add_per_epoch_subsidies(Arg0: &mut SystemStateInnerV1, Arg1: vector<Balance<WAL>>) {

L2: loc0: u64

L3: loc1: u32

L4: loc2: u64

L5: loc3: Balance<WAL>

L6: loc4: u64

L7: loc5: vector<Balance<WAL>>

B0:

0ImmBorrowLoc[1](Arg1: vector<Balance<WAL>>)

1VecLen(5)

2CopyLoc[0](Arg0: &mut SystemStateInnerV1)

3ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

4Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

5CastU64

6Le

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[0](Arg0: &mut SystemStateInnerV1)

10Pop

11LdConst[4](u64: 2)

12Abort

B3:

13LdU32(0)

14StLoc[3](loc1: u32)

15MoveLoc[1](Arg1: vector<Balance<WAL>>)

16StLoc[7](loc5: vector<Balance<WAL>>)

17MutBorrowLoc[7](loc5: vector<Balance<WAL>>)

18Call vector::reverse<Balance<WAL>>(&mut vector<Balance<WAL>>)

19ImmBorrowLoc[7](loc5: vector<Balance<WAL>>)

20VecLen(5)

21StLoc[2](loc0: u64)

22LdU64(0)

23StLoc[4](loc2: u64)

24MoveLoc[2](loc0: u64)

25StLoc[6](loc4: u64)

B4:

26CopyLoc[4](loc2: u64)

27CopyLoc[6](loc4: u64)

28Lt

29BrFalse(52)

B5:

30CopyLoc[4](loc2: u64)

31Pop

32MutBorrowLoc[7](loc5: vector<Balance<WAL>>)

33VecPopBack(5)

34StLoc[5](loc3: Balance<WAL>)

35CopyLoc[0](Arg0: &mut SystemStateInnerV1)

36MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

37CopyLoc[3](loc1: u32)

38Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

39Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

40MoveLoc[5](loc3: Balance<WAL>)

41Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

42Pop

43MoveLoc[3](loc1: u32)

44LdU32(1)

45Add

46StLoc[3](loc1: u32)

47MoveLoc[4](loc2: u64)

48LdU64(1)

49Add

50StLoc[4](loc2: u64)

51Branch(26)

B6:

52MoveLoc[0](Arg0: &mut SystemStateInnerV1)

53Pop

54MoveLoc[7](loc5: vector<Balance<WAL>>)

55VecUnpack(5, 0)

56Ret

}

public(friend) epoch(Arg0: &SystemStateInnerV1): u32 {

B0:

0MoveLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

2Call bls_aggregate::epoch(&BlsCommittee): u32

3Ret

}

public(friend) total_capacity_size(Arg0: &SystemStateInnerV1): u64 {

B0:

0MoveLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[4](SystemStateInnerV1.total_capacity_size: u64)

2ReadRef

3Ret

}

public(friend) used_capacity_size(Arg0: &SystemStateInnerV1): u64 {

B0:

0MoveLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[3](SystemStateInnerV1.used_capacity_size: u64)

2ReadRef

3Ret

}

public(friend) committee(Arg0: &SystemStateInnerV1): &BlsCommittee {

B0:

0MoveLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

2Ret

}

public(friend) future_accounting(Arg0: &SystemStateInnerV1): &FutureAccountingRingBuffer {

B0:

0MoveLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

2Ret

}

public(friend) n_shards(Arg0: &SystemStateInnerV1): u16 {

B0:

0MoveLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

2Call bls_aggregate::n_shards(&BlsCommittee): u16

3Ret

}

public(friend) write_price(Arg0: &SystemStateInnerV1, Arg1: u64): u64 {

L2: loc0: u64

B0:

0MoveLoc[1](Arg1: u64)

1LdConst[1](u64: 1048..)

2Call u64::div_ceil(u64, u64): u64

3StLoc[2](loc0: u64)

4MoveLoc[0](Arg0: &SystemStateInnerV1)

5ImmBorrowField[7](SystemStateInnerV1.write_price_per_unit_size: u64)

6ReadRef

7MoveLoc[2](loc0: u64)

8Mul

9Ret

}

public(friend) set_storage_price(Arg0: &mut SystemStateInnerV1, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

1MoveLoc[0](Arg0: &mut SystemStateInnerV1)

2MutBorrowField[6](SystemStateInnerV1.storage_price_per_unit_size: u64)

3WriteRef

4Ret

}

public(friend) set_write_price(Arg0: &mut SystemStateInnerV1, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

1MoveLoc[0](Arg0: &mut SystemStateInnerV1)

2MutBorrowField[7](SystemStateInnerV1.write_price_per_unit_size: u64)

3WriteRef

4Ret

}

public(friend) update_protocol_version(Arg0: &SystemStateInnerV1, Arg1: &StorageNodeCap, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>) {

L5: loc0: ID

L6: loc1: &BlsCommittee

L7: loc2: CertifiedMessage

L8: loc3: u32

L9: loc4: ProtocolVersionMessage

L10: loc5: u32

B0:

0CopyLoc[0](Arg0: &SystemStateInnerV1)

1Call committee(&SystemStateInnerV1): &BlsCommittee

2StLoc[6](loc1: &BlsCommittee)

3MoveLoc[1](Arg1: &StorageNodeCap)

4Call storage_node::node_id(&StorageNodeCap): ID

5StLoc[5](loc0: ID)

6MoveLoc[6](loc1: &BlsCommittee)

7ImmBorrowLoc[5](loc0: ID)

8Call bls_aggregate::contains(&BlsCommittee, &ID): bool

9BrFalse(11)

B1:

10Branch(15)

B2:

11MoveLoc[0](Arg0: &SystemStateInnerV1)

12Pop

13LdConst[10](u64: 8)

14Abort

B3:

15CopyLoc[0](Arg0: &SystemStateInnerV1)

16ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

17MoveLoc[2](Arg2: vector<u8>)

18MoveLoc[3](Arg3: vector<u8>)

19MoveLoc[4](Arg4: vector<u8>)

20Call bls_aggregate::verify_quorum_in_epoch(&BlsCommittee, vector<u8>, vector<u8>, vector<u8>): CertifiedMessage

21StLoc[7](loc2: CertifiedMessage)

22ImmBorrowLoc[7](loc2: CertifiedMessage)

23Call messages::cert_epoch(&CertifiedMessage): u32

24StLoc[8](loc3: u32)

25MoveLoc[7](loc2: CertifiedMessage)

26Call messages::protocol_version_message(CertifiedMessage): ProtocolVersionMessage

27StLoc[9](loc4: ProtocolVersionMessage)

28ImmBorrowLoc[9](loc4: ProtocolVersionMessage)

29Call messages::start_epoch(&ProtocolVersionMessage): u32

30StLoc[10](loc5: u32)

31CopyLoc[8](loc3: u32)

32CopyLoc[0](Arg0: &SystemStateInnerV1)

33Call epoch(&SystemStateInnerV1): u32

34Eq

35BrFalse(37)

B4:

36Branch(41)

B5:

37MoveLoc[0](Arg0: &SystemStateInnerV1)

38Pop

39LdConst[5](u64: 3)

40Abort

B6:

41MoveLoc[10](loc5: u32)

42MoveLoc[0](Arg0: &SystemStateInnerV1)

43Call epoch(&SystemStateInnerV1): u32

44Ge

45BrFalse(47)

B7:

46Branch(49)

B8:

47LdConst[14](u64: 12)

48Abort

B9:

49MoveLoc[8](loc3: u32)

50ImmBorrowLoc[9](loc4: ProtocolVersionMessage)

51Call messages::start_epoch(&ProtocolVersionMessage): u32

52ImmBorrowLoc[9](loc4: ProtocolVersionMessage)

53Call messages::protocol_version(&ProtocolVersionMessage): u64

54Call events::emit_protocol_version(u32, u32, u64)

55Ret

}

public(friend) register_deny_list_update(Arg0: &SystemStateInnerV1, Arg1: &StorageNodeCap, Arg2: u256, Arg3: u64) {

L4: loc0: ID

L5: loc1: &BlsCommittee

B0:

0CopyLoc[0](Arg0: &SystemStateInnerV1)

1Call committee(&SystemStateInnerV1): &BlsCommittee

2StLoc[5](loc1: &BlsCommittee)

3CopyLoc[1](Arg1: &StorageNodeCap)

4Call storage_node::node_id(&StorageNodeCap): ID

5StLoc[4](loc0: ID)

6MoveLoc[5](loc1: &BlsCommittee)

7ImmBorrowLoc[4](loc0: ID)

8Call bls_aggregate::contains(&BlsCommittee, &ID): bool

9BrFalse(11)

B1:

10Branch(17)

B2:

11MoveLoc[0](Arg0: &SystemStateInnerV1)

12Pop

13MoveLoc[1](Arg1: &StorageNodeCap)

14Pop

15LdConst[10](u64: 8)

16Abort

B3:

17CopyLoc[3](Arg3: u64)

18CopyLoc[1](Arg1: &StorageNodeCap)

19Call storage_node::deny_list_sequence(&StorageNodeCap): u64

20Gt

21BrFalse(23)

B4:

22Branch(29)

B5:

23MoveLoc[0](Arg0: &SystemStateInnerV1)

24Pop

25MoveLoc[1](Arg1: &StorageNodeCap)

26Pop

27LdConst[11](u64: 9)

28Abort

B6:

29MoveLoc[0](Arg0: &SystemStateInnerV1)

30Call epoch(&SystemStateInnerV1): u32

31MoveLoc[2](Arg2: u256)

32MoveLoc[3](Arg3: u64)

33MoveLoc[1](Arg1: &StorageNodeCap)

34Call storage_node::node_id(&StorageNodeCap): ID

35Call events::emit_register_deny_list_update(u32, u256, u64, ID)

36Ret

}

public(friend) update_deny_list(Arg0: &mut SystemStateInnerV1, Arg1: &mut StorageNodeCap, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>) {

L5: loc0: ID

L6: loc1: &BlsCommittee

L7: loc2: CertifiedMessage

L8: loc3: u256

L9: loc4: u32

L10: loc5: DenyListUpdateMessage

L11: loc6: ID

L12: loc7: u64

L13: loc8: u64

L14: loc9: &mut VecMap<ID, u64>

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1FreezeRef

2Call committee(&SystemStateInnerV1): &BlsCommittee

3StLoc[6](loc1: &BlsCommittee)

4CopyLoc[1](Arg1: &mut StorageNodeCap)

5FreezeRef

6Call storage_node::node_id(&StorageNodeCap): ID

7StLoc[5](loc0: ID)

8MoveLoc[6](loc1: &BlsCommittee)

9ImmBorrowLoc[5](loc0: ID)

10Call bls_aggregate::contains(&BlsCommittee, &ID): bool

11BrFalse(13)

B1:

12Branch(19)

B2:

13MoveLoc[0](Arg0: &mut SystemStateInnerV1)

14Pop

15MoveLoc[1](Arg1: &mut StorageNodeCap)

16Pop

17LdConst[10](u64: 8)

18Abort

B3:

19CopyLoc[0](Arg0: &mut SystemStateInnerV1)

20ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

21MoveLoc[2](Arg2: vector<u8>)

22MoveLoc[3](Arg3: vector<u8>)

23MoveLoc[4](Arg4: vector<u8>)

24Call bls_aggregate::verify_quorum_in_epoch(&BlsCommittee, vector<u8>, vector<u8>, vector<u8>): CertifiedMessage

25StLoc[7](loc2: CertifiedMessage)

26ImmBorrowLoc[7](loc2: CertifiedMessage)

27Call messages::cert_epoch(&CertifiedMessage): u32

28StLoc[9](loc4: u32)

29MoveLoc[7](loc2: CertifiedMessage)

30Call messages::deny_list_update_message(CertifiedMessage): DenyListUpdateMessage

31StLoc[10](loc5: DenyListUpdateMessage)

32ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

33Call messages::storage_node_id(&DenyListUpdateMessage): ID

34StLoc[11](loc6: ID)

35ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

36Call messages::size(&DenyListUpdateMessage): u64

37StLoc[13](loc8: u64)

38MoveLoc[9](loc4: u32)

39CopyLoc[0](Arg0: &mut SystemStateInnerV1)

40FreezeRef

41Call epoch(&SystemStateInnerV1): u32

42Eq

43BrFalse(45)

B4:

44Branch(51)

B5:

45MoveLoc[0](Arg0: &mut SystemStateInnerV1)

46Pop

47MoveLoc[1](Arg1: &mut StorageNodeCap)

48Pop

49LdConst[5](u64: 3)

50Abort

B6:

51CopyLoc[11](loc6: ID)

52CopyLoc[1](Arg1: &mut StorageNodeCap)

53FreezeRef

54Call storage_node::node_id(&StorageNodeCap): ID

55Eq

56BrFalse(58)

B7:

57Branch(64)

B8:

58MoveLoc[0](Arg0: &mut SystemStateInnerV1)

59Pop

60MoveLoc[1](Arg1: &mut StorageNodeCap)

61Pop

62LdConst[12](u64: 10)

63Abort

B9:

64CopyLoc[1](Arg1: &mut StorageNodeCap)

65FreezeRef

66Call storage_node::deny_list_sequence(&StorageNodeCap): u64

67ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

68Call messages::sequence_number(&DenyListUpdateMessage): u64

69Lt

70BrFalse(72)

B10:

71Branch(78)

B11:

72MoveLoc[0](Arg0: &mut SystemStateInnerV1)

73Pop

74MoveLoc[1](Arg1: &mut StorageNodeCap)

75Pop

76LdConst[11](u64: 9)

77Abort

B12:

78ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

79Call messages::root(&DenyListUpdateMessage): u256

80StLoc[8](loc3: u256)

81ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

82Call messages::sequence_number(&DenyListUpdateMessage): u64

83StLoc[12](loc7: u64)

84CopyLoc[1](Arg1: &mut StorageNodeCap)

85CopyLoc[8](loc3: u256)

86CopyLoc[12](loc7: u64)

87MoveLoc[13](loc8: u64)

88Call storage_node::set_deny_list_properties(&mut StorageNodeCap, u256, u64, u64)

89CopyLoc[0](Arg0: &mut SystemStateInnerV1)

90MutBorrowField[5](SystemStateInnerV1.deny_list_sizes: ExtendedField<VecMap<ID, u64>>)

91Call extended_field::borrow_mut<VecMap<ID, u64>>(&mut ExtendedField<VecMap<ID, u64>>): &mut VecMap<ID, u64>

92StLoc[14](loc9: &mut VecMap<ID, u64>)

93CopyLoc[14](loc9: &mut VecMap<ID, u64>)

94FreezeRef

95ImmBorrowLoc[11](loc6: ID)

96Call vec_map::contains<ID, u64>(&VecMap<ID, u64>, &ID): bool

97BrFalse(105)

B13:

98ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

99Call messages::size(&DenyListUpdateMessage): u64

100MoveLoc[14](loc9: &mut VecMap<ID, u64>)

101ImmBorrowLoc[11](loc6: ID)

102Call vec_map::get_mut<ID, u64>(&mut VecMap<ID, u64>, &ID): &mut u64

103WriteRef

104Branch(110)

B14:

105MoveLoc[14](loc9: &mut VecMap<ID, u64>)

106MoveLoc[11](loc6: ID)

107ImmBorrowLoc[10](loc5: DenyListUpdateMessage)

108Call messages::size(&DenyListUpdateMessage): u64

109Call vec_map::insert<ID, u64>(&mut VecMap<ID, u64>, ID, u64)

B15:

110MoveLoc[0](Arg0: &mut SystemStateInnerV1)

111FreezeRef

112Call epoch(&SystemStateInnerV1): u32

113MoveLoc[8](loc3: u256)

114MoveLoc[12](loc7: u64)

115MoveLoc[1](Arg1: &mut StorageNodeCap)

116FreezeRef

117Call storage_node::node_id(&StorageNodeCap): ID

118Call events::emit_deny_list_update(u32, u256, u64, ID)

119Ret

}

public(friend) delete_deny_listed_blob(Arg0: &SystemStateInnerV1, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>) {

L4: loc0: CertifiedMessage

L5: loc1: u32

L6: loc2: DenyListBlobDeleted

B0:

0CopyLoc[0](Arg0: &SystemStateInnerV1)

1ImmBorrowField[0](SystemStateInnerV1.committee: BlsCommittee)

2MoveLoc[1](Arg1: vector<u8>)

3MoveLoc[2](Arg2: vector<u8>)

4MoveLoc[3](Arg3: vector<u8>)

5Call bls_aggregate::verify_one_correct_node_in_epoch(&BlsCommittee, vector<u8>, vector<u8>, vector<u8>): CertifiedMessage

6StLoc[4](loc0: CertifiedMessage)

7ImmBorrowLoc[4](loc0: CertifiedMessage)

8Call messages::cert_epoch(&CertifiedMessage): u32

9StLoc[5](loc1: u32)

10MoveLoc[4](loc0: CertifiedMessage)

11Call messages::deny_list_blob_deleted_message(CertifiedMessage): DenyListBlobDeleted

12StLoc[6](loc2: DenyListBlobDeleted)

13CopyLoc[5](loc1: u32)

14MoveLoc[0](Arg0: &SystemStateInnerV1)

15Call epoch(&SystemStateInnerV1): u32

16Eq

17BrFalse(19)

B1:

18Branch(21)

B2:

19LdConst[5](u64: 3)

20Abort

B3:

21MoveLoc[5](loc1: u32)

22ImmBorrowLoc[6](loc2: DenyListBlobDeleted)

23Call messages::blob_id(&DenyListBlobDeleted): u256

24Call events::emit_deny_listed_blob_deleted(u32, u256)

25Ret

}

public(friend) create_storage_pool(Arg0: &mut SystemStateInnerV1, Arg1: u64, Arg2: u32, Arg3: &mut Coin<WAL>, Arg4: &mut TxContext): StoragePool {

L5: loc0: Storage

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1MoveLoc[1](Arg1: u64)

2MoveLoc[2](Arg2: u32)

3MoveLoc[3](Arg3: &mut Coin<WAL>)

4CopyLoc[4](Arg4: &mut TxContext)

5Call reserve_space(&mut SystemStateInnerV1, u64, u32, &mut Coin<WAL>, &mut TxContext): Storage

6StLoc[5](loc0: Storage)

7MoveLoc[0](Arg0: &mut SystemStateInnerV1)

8FreezeRef

9MoveLoc[5](loc0: Storage)

10MoveLoc[4](Arg4: &mut TxContext)

11Call create_storage_pool_with_storage(&SystemStateInnerV1, Storage, &mut TxContext): StoragePool

12Ret

}

public(friend) create_storage_pool_with_storage(Arg0: &SystemStateInnerV1, Arg1: Storage, Arg2: &mut TxContext): StoragePool {

L3: loc0: StoragePool

B0:

0ImmBorrowLoc[1](Arg1: Storage)

1Call storage_resource::size(&Storage): u64

2LdU64(0)

3Gt

4BrFalse(6)

B1:

5Branch(12)

B2:

6MoveLoc[0](Arg0: &SystemStateInnerV1)

7Pop

8MoveLoc[2](Arg2: &mut TxContext)

9Pop

10LdConst[13](u64: 11)

11Abort

B3:

12ImmBorrowLoc[1](Arg1: Storage)

13Call storage_resource::start_epoch(&Storage): u32

14CopyLoc[0](Arg0: &SystemStateInnerV1)

15Call epoch(&SystemStateInnerV1): u32

16Le

17BrFalse(19)

B4:

18Branch(25)

B5:

19MoveLoc[0](Arg0: &SystemStateInnerV1)

20Pop

21MoveLoc[2](Arg2: &mut TxContext)

22Pop

23LdConst[4](u64: 2)

24Abort

B6:

25ImmBorrowLoc[1](Arg1: Storage)

26Call storage_resource::end_epoch(&Storage): u32

27CopyLoc[0](Arg0: &SystemStateInnerV1)

28Call epoch(&SystemStateInnerV1): u32

29Gt

30BrFalse(32)

B7:

31Branch(38)

B8:

32MoveLoc[0](Arg0: &SystemStateInnerV1)

33Pop

34MoveLoc[2](Arg2: &mut TxContext)

35Pop

36LdConst[4](u64: 2)

37Abort

B9:

38MoveLoc[1](Arg1: Storage)

39MoveLoc[2](Arg2: &mut TxContext)

40Call storage_pool::create(Storage, &mut TxContext): StoragePool

41StLoc[3](loc0: StoragePool)

42MoveLoc[0](Arg0: &SystemStateInnerV1)

43Call epoch(&SystemStateInnerV1): u32

44ImmBorrowLoc[3](loc0: StoragePool)

45Call storage_pool::object_id(&StoragePool): ID

46ImmBorrowLoc[3](loc0: StoragePool)

47Call storage_pool::reserved_encoded_capacity_bytes(&StoragePool): u64

48ImmBorrowLoc[3](loc0: StoragePool)

49Call storage_pool::start_epoch(&StoragePool): u32

50ImmBorrowLoc[3](loc0: StoragePool)

51Call storage_pool::end_epoch(&StoragePool): u32

52Call events::emit_storage_pool_created(u32, ID, u64, u32, u32)

53MoveLoc[3](loc0: StoragePool)

54Ret

}

public(friend) register_pooled_blob(Arg0: &mut SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u256, Arg3: u256, Arg4: u64, Arg5: u8, Arg6: bool, Arg7: &mut Coin<WAL>, Arg8: &mut TxContext) {

L9: loc0: u64

L10: loc1: Balance<WAL>

L11: loc2: PooledBlob

L12: loc3: u64

B0:

0CopyLoc[0](Arg0: &mut SystemStateInnerV1)

1FreezeRef

2Call epoch(&SystemStateInnerV1): u32

3CopyLoc[1](Arg1: &mut StoragePool)

4FreezeRef

5Call storage_pool::start_epoch(&StoragePool): u32

6Ge

7BrFalse(9)

B1:

8Branch(19)

B2:

9MoveLoc[7](Arg7: &mut Coin<WAL>)

10Pop

11MoveLoc[1](Arg1: &mut StoragePool)

12Pop

13MoveLoc[0](Arg0: &mut SystemStateInnerV1)

14Pop

15MoveLoc[8](Arg8: &mut TxContext)

16Pop

17LdConst[4](u64: 2)

18Abort

B3:

19CopyLoc[0](Arg0: &mut SystemStateInnerV1)

20FreezeRef

21Call epoch(&SystemStateInnerV1): u32

22CopyLoc[1](Arg1: &mut StoragePool)

23FreezeRef

24Call storage_pool::end_epoch(&StoragePool): u32

25Lt

26BrFalse(28)

B4:

27Branch(38)

B5:

28MoveLoc[7](Arg7: &mut Coin<WAL>)

29Pop

30MoveLoc[1](Arg1: &mut StoragePool)

31Pop

32MoveLoc[0](Arg0: &mut SystemStateInnerV1)

33Pop

34MoveLoc[8](Arg8: &mut TxContext)

35Pop

36LdConst[4](u64: 2)

37Abort

B6:

38CopyLoc[1](Arg1: &mut StoragePool)

39FreezeRef

40Call storage_pool::object_id(&StoragePool): ID

41MoveLoc[2](Arg2: u256)

42MoveLoc[3](Arg3: u256)

43CopyLoc[4](Arg4: u64)

44CopyLoc[5](Arg5: u8)

45MoveLoc[6](Arg6: bool)

46CopyLoc[0](Arg0: &mut SystemStateInnerV1)

47FreezeRef

48Call epoch(&SystemStateInnerV1): u32

49MoveLoc[8](Arg8: &mut TxContext)

50Call storage_pool::new_pooled_blob(ID, u256, u256, u64, u8, bool, u32, &mut TxContext): PooledBlob

51StLoc[11](loc2: PooledBlob)

52MoveLoc[4](Arg4: u64)

53MoveLoc[5](Arg5: u8)

54CopyLoc[0](Arg0: &mut SystemStateInnerV1)

55FreezeRef

56Call n_shards(&SystemStateInnerV1): u16

57Call encoding::encoded_blob_length(u64, u8, u16): u64

58StLoc[9](loc0: u64)

59MoveLoc[1](Arg1: &mut StoragePool)

60MoveLoc[11](loc2: PooledBlob)

61CopyLoc[9](loc0: u64)

62Call storage_pool::add_blob(&mut StoragePool, PooledBlob, u64)

63CopyLoc[0](Arg0: &mut SystemStateInnerV1)

64FreezeRef

65MoveLoc[9](loc0: u64)

66Call write_price(&SystemStateInnerV1, u64): u64

67StLoc[12](loc3: u64)

68MoveLoc[7](Arg7: &mut Coin<WAL>)

69Call coin::balance_mut<WAL>(&mut Coin<WAL>): &mut Balance<WAL>

70MoveLoc[12](loc3: u64)

71Call balance::split<WAL>(&mut Balance<WAL>, u64): Balance<WAL>

72StLoc[10](loc1: Balance<WAL>)

73MoveLoc[0](Arg0: &mut SystemStateInnerV1)

74MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

75LdU32(0)

76Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

77Call storage_accounting::rewards_balance(&mut FutureAccounting): &mut Balance<WAL>

78MoveLoc[10](loc1: Balance<WAL>)

79Call balance::join<WAL>(&mut Balance<WAL>, Balance<WAL>): u64

80Pop

81Ret

}

public(friend) delete_pooled_blob(Arg0: &SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u256) {

B0:

0CopyLoc[1](Arg1: &mut StoragePool)

1FreezeRef

2Call storage_pool::end_epoch(&StoragePool): u32

3CopyLoc[0](Arg0: &SystemStateInnerV1)

4Call epoch(&SystemStateInnerV1): u32

5Gt

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &mut StoragePool)

9Pop

10MoveLoc[0](Arg0: &SystemStateInnerV1)

11Pop

12LdConst[4](u64: 2)

13Abort

B3:

14MoveLoc[1](Arg1: &mut StoragePool)

15MoveLoc[2](Arg2: u256)

16CopyLoc[0](Arg0: &SystemStateInnerV1)

17Call n_shards(&SystemStateInnerV1): u16

18Call storage_pool::remove_blob(&mut StoragePool, u256, u16): PooledBlob

19MoveLoc[0](Arg0: &SystemStateInnerV1)

20Call epoch(&SystemStateInnerV1): u32

21Call storage_pool::delete_blob_object(PooledBlob, u32)

22Ret

}

public(friend) burn_expired_pooled_blob(Arg0: &SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u256) {

B0:

0CopyLoc[1](Arg1: &mut StoragePool)

1FreezeRef

2Call storage_pool::end_epoch(&StoragePool): u32

3CopyLoc[0](Arg0: &SystemStateInnerV1)

4Call epoch(&SystemStateInnerV1): u32

5Le

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &mut StoragePool)

9Pop

10MoveLoc[0](Arg0: &SystemStateInnerV1)

11Pop

12LdConst[4](u64: 2)

13Abort

B3:

14MoveLoc[1](Arg1: &mut StoragePool)

15MoveLoc[2](Arg2: u256)

16MoveLoc[0](Arg0: &SystemStateInnerV1)

17Call n_shards(&SystemStateInnerV1): u16

18Call storage_pool::remove_blob(&mut StoragePool, u256, u16): PooledBlob

19Call storage_pool::burn_blob_object(PooledBlob)

20Ret

}

public(friend) extend_storage_pool(Arg0: &mut SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u32, Arg3: &mut Coin<WAL>) {

L4: loc0: u32

L5: loc1: u32

B0:

0CopyLoc[2](Arg2: u32)

1LdU32(0)

2Gt

3BrFalse(5)

B1:

4Branch(13)

B2:

5MoveLoc[1](Arg1: &mut StoragePool)

6Pop

7MoveLoc[0](Arg0: &mut SystemStateInnerV1)

8Pop

9MoveLoc[3](Arg3: &mut Coin<WAL>)

10Pop

11LdConst[4](u64: 2)

12Abort

B3:

13CopyLoc[1](Arg1: &mut StoragePool)

14FreezeRef

15Call storage_pool::end_epoch(&StoragePool): u32

16CopyLoc[0](Arg0: &mut SystemStateInnerV1)

17FreezeRef

18Call epoch(&SystemStateInnerV1): u32

19Gt

20BrFalse(22)

B4:

21Branch(30)

B5:

22MoveLoc[1](Arg1: &mut StoragePool)

23Pop

24MoveLoc[0](Arg0: &mut SystemStateInnerV1)

25Pop

26MoveLoc[3](Arg3: &mut Coin<WAL>)

27Pop

28LdConst[4](u64: 2)

29Abort

B6:

30CopyLoc[1](Arg1: &mut StoragePool)

31FreezeRef

32Call storage_pool::end_epoch(&StoragePool): u32

33CopyLoc[0](Arg0: &mut SystemStateInnerV1)

34FreezeRef

35Call epoch(&SystemStateInnerV1): u32

36Sub

37StLoc[5](loc1: u32)

38CopyLoc[5](loc1: u32)

39CopyLoc[2](Arg2: u32)

40Add

41StLoc[4](loc0: u32)

42CopyLoc[4](loc0: u32)

43CopyLoc[0](Arg0: &mut SystemStateInnerV1)

44ImmBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

45Call storage_accounting::max_epochs_ahead(&FutureAccountingRingBuffer): u32

46Le

47BrFalse(49)

B7:

48Branch(57)

B8:

49MoveLoc[1](Arg1: &mut StoragePool)

50Pop

51MoveLoc[0](Arg0: &mut SystemStateInnerV1)

52Pop

53MoveLoc[3](Arg3: &mut Coin<WAL>)

54Pop

55LdConst[4](u64: 2)

56Abort

B9:

57CopyLoc[0](Arg0: &mut SystemStateInnerV1)

58CopyLoc[1](Arg1: &mut StoragePool)

59FreezeRef

60Call storage_pool::reserved_encoded_capacity_bytes(&StoragePool): u64

61CopyLoc[5](loc1: u32)

62CopyLoc[4](loc0: u32)

63MoveLoc[3](Arg3: &mut Coin<WAL>)

64Call process_storage_payments(&mut SystemStateInnerV1, u64, u32, u32, &mut Coin<WAL>)

65CopyLoc[0](Arg0: &mut SystemStateInnerV1)

66MoveLoc[5](loc1: u32)

67MoveLoc[4](loc0: u32)

68CopyLoc[1](Arg1: &mut StoragePool)

69FreezeRef

70Call storage_pool::reserved_encoded_capacity_bytes(&StoragePool): u64

71Call account_capacity(&mut SystemStateInnerV1, u32, u32, u64)

72CopyLoc[1](Arg1: &mut StoragePool)

73MoveLoc[2](Arg2: u32)

74Call storage_pool::extend_end_epoch(&mut StoragePool, u32)

75MoveLoc[0](Arg0: &mut SystemStateInnerV1)

76FreezeRef

77Call epoch(&SystemStateInnerV1): u32

78CopyLoc[1](Arg1: &mut StoragePool)

79FreezeRef

80Call storage_pool::object_id(&StoragePool): ID

81MoveLoc[1](Arg1: &mut StoragePool)

82FreezeRef

83Call storage_pool::end_epoch(&StoragePool): u32

84Call events::emit_storage_pool_extended(u32, ID, u32)

85Ret

}

public(friend) increase_storage_pool_capacity(Arg0: &mut SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u64, Arg3: &mut Coin<WAL>) {

L4: loc0: u32

B0:

0CopyLoc[2](Arg2: u64)

1LdU64(0)

2Gt

3BrFalse(5)

B1:

4Branch(13)

B2:

5MoveLoc[1](Arg1: &mut StoragePool)

6Pop

7MoveLoc[0](Arg0: &mut SystemStateInnerV1)

8Pop

9MoveLoc[3](Arg3: &mut Coin<WAL>)

10Pop

11LdConst[13](u64: 11)

12Abort

B3:

13CopyLoc[1](Arg1: &mut StoragePool)

14FreezeRef

15Call storage_pool::end_epoch(&StoragePool): u32

16CopyLoc[0](Arg0: &mut SystemStateInnerV1)

17FreezeRef

18Call epoch(&SystemStateInnerV1): u32

19Gt

20BrFalse(22)

B4:

21Branch(30)

B5:

22MoveLoc[1](Arg1: &mut StoragePool)

23Pop

24MoveLoc[0](Arg0: &mut SystemStateInnerV1)

25Pop

26MoveLoc[3](Arg3: &mut Coin<WAL>)

27Pop

28LdConst[4](u64: 2)

29Abort

B6:

30CopyLoc[1](Arg1: &mut StoragePool)

31FreezeRef

32Call storage_pool::end_epoch(&StoragePool): u32

33CopyLoc[0](Arg0: &mut SystemStateInnerV1)

34FreezeRef

35Call epoch(&SystemStateInnerV1): u32

36Sub

37StLoc[4](loc0: u32)

38CopyLoc[0](Arg0: &mut SystemStateInnerV1)

39CopyLoc[2](Arg2: u64)

40LdU32(0)

41CopyLoc[4](loc0: u32)

42MoveLoc[3](Arg3: &mut Coin<WAL>)

43Call process_storage_payments(&mut SystemStateInnerV1, u64, u32, u32, &mut Coin<WAL>)

44MoveLoc[0](Arg0: &mut SystemStateInnerV1)

45LdU32(0)

46MoveLoc[4](loc0: u32)

47CopyLoc[2](Arg2: u64)

48Call account_capacity(&mut SystemStateInnerV1, u32, u32, u64)

49MoveLoc[1](Arg1: &mut StoragePool)

50MoveLoc[2](Arg2: u64)

51Call storage_pool::increase_reserved_encoded_capacity(&mut StoragePool, u64)

52Ret

}

public(friend) increase_storage_pool_capacity_with_storage(Arg0: &SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: Storage) {

B0:

0CopyLoc[1](Arg1: &mut StoragePool)

1FreezeRef

2Call storage_pool::end_epoch(&StoragePool): u32

3CopyLoc[0](Arg0: &SystemStateInnerV1)

4Call epoch(&SystemStateInnerV1): u32

5Gt

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &mut StoragePool)

9Pop

10MoveLoc[0](Arg0: &SystemStateInnerV1)

11Pop

12LdConst[4](u64: 2)

13Abort

B3:

14MoveLoc[1](Arg1: &mut StoragePool)

15MoveLoc[2](Arg2: Storage)

16MoveLoc[0](Arg0: &SystemStateInnerV1)

17Call epoch(&SystemStateInnerV1): u32

18Call storage_pool::increase_capacity_with_storage(&mut StoragePool, Storage, u32)

19Ret

}

public(friend) decrease_storage_pool_capacity_by_size(Arg0: &SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u64, Arg3: &mut TxContext): Option<Storage> {

B0:

0CopyLoc[1](Arg1: &mut StoragePool)

1FreezeRef

2Call storage_pool::end_epoch(&StoragePool): u32

3MoveLoc[0](Arg0: &SystemStateInnerV1)

4Call epoch(&SystemStateInnerV1): u32

5Gt

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &mut StoragePool)

9Pop

10MoveLoc[3](Arg3: &mut TxContext)

11Pop

12LdConst[4](u64: 2)

13Abort

B3:

14MoveLoc[1](Arg1: &mut StoragePool)

15MoveLoc[2](Arg2: u64)

16MoveLoc[3](Arg3: &mut TxContext)

17Call storage_pool::decrease_capacity_by_size(&mut StoragePool, u64, &mut TxContext): Option<Storage>

18Ret

}

public(friend) decrease_storage_pool_unused_capacity_by_percent(Arg0: &SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u8, Arg3: &mut TxContext): Option<Storage> {

B0:

0CopyLoc[1](Arg1: &mut StoragePool)

1FreezeRef

2Call storage_pool::end_epoch(&StoragePool): u32

3MoveLoc[0](Arg0: &SystemStateInnerV1)

4Call epoch(&SystemStateInnerV1): u32

5Gt

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &mut StoragePool)

9Pop

10MoveLoc[3](Arg3: &mut TxContext)

11Pop

12LdConst[4](u64: 2)

13Abort

B3:

14MoveLoc[1](Arg1: &mut StoragePool)

15MoveLoc[2](Arg2: u8)

16MoveLoc[3](Arg3: &mut TxContext)

17Call storage_pool::decrease_unused_capacity_by_percent(&mut StoragePool, u8, &mut TxContext): Option<Storage>

18Ret

}

public(friend) certify_pooled_blob(Arg0: &SystemStateInnerV1, Arg1: &mut StoragePool, Arg2: u256, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: vector<u8>) {

L6: loc0: CertifiedBlobMessage

L7: loc1: CertifiedMessage

L8: loc2: u32

B0:

0CopyLoc[0](Arg0: &SystemStateInnerV1)

1Call committee(&SystemStateInnerV1): &BlsCommittee

2MoveLoc[3](Arg3: vector<u8>)

3MoveLoc[4](Arg4: vector<u8>)

4MoveLoc[5](Arg5: vector<u8>)

5Call bls_aggregate::verify_quorum_in_epoch(&BlsCommittee, vector<u8>, vector<u8>, vector<u8>): CertifiedMessage

6StLoc[7](loc1: CertifiedMessage)

7ImmBorrowLoc[7](loc1: CertifiedMessage)

8Call messages::cert_epoch(&CertifiedMessage): u32

9CopyLoc[0](Arg0: &SystemStateInnerV1)

10Call epoch(&SystemStateInnerV1): u32

11Eq

12BrFalse(14)

B1:

13Branch(20)

B2:

14MoveLoc[1](Arg1: &mut StoragePool)

15Pop

16MoveLoc[0](Arg0: &SystemStateInnerV1)

17Pop

18LdConst[5](u64: 3)

19Abort

B3:

20MoveLoc[7](loc1: CertifiedMessage)

21Call messages::certify_blob_message(CertifiedMessage): CertifiedBlobMessage

22StLoc[6](loc0: CertifiedBlobMessage)

23CopyLoc[1](Arg1: &mut StoragePool)

24FreezeRef

25Call storage_pool::end_epoch(&StoragePool): u32

26StLoc[8](loc2: u32)

27MoveLoc[1](Arg1: &mut StoragePool)

28MoveLoc[2](Arg2: u256)

29Call storage_pool::borrow_blob_mut(&mut StoragePool, u256): &mut PooledBlob

30MoveLoc[0](Arg0: &SystemStateInnerV1)

31Call epoch(&SystemStateInnerV1): u32

32MoveLoc[8](loc2: u32)

33MoveLoc[6](loc0: CertifiedBlobMessage)

34Call storage_pool::certify(&mut PooledBlob, u32, u32, CertifiedBlobMessage)

35Ret

}

account_capacity(Arg0: &mut SystemStateInnerV1, Arg1: u32, Arg2: u32, Arg3: u64) {

L4: loc0: u32

L5: loc1: u32

L6: loc2: u32

L7: loc3: u64

B0:

0MoveLoc[1](Arg1: u32)

1StLoc[4](loc0: u32)

2MoveLoc[2](Arg2: u32)

3StLoc[6](loc2: u32)

B1:

4CopyLoc[4](loc0: u32)

5CopyLoc[6](loc2: u32)

6Lt

7BrFalse(41)

B2:

8CopyLoc[4](loc0: u32)

9StLoc[5](loc1: u32)

10CopyLoc[0](Arg0: &mut SystemStateInnerV1)

11MutBorrowField[1](SystemStateInnerV1.future_accounting: FutureAccountingRingBuffer)

12CopyLoc[5](loc1: u32)

13Call storage_accounting::ring_lookup_mut(&mut FutureAccountingRingBuffer, u32): &mut FutureAccounting

14CopyLoc[3](Arg3: u64)

15Call storage_accounting::increase_used_capacity(&mut FutureAccounting, u64): u64

16StLoc[7](loc3: u64)

17MoveLoc[5](loc1: u32)

18LdU32(0)

19Eq

20BrFalse(25)

B3:

21CopyLoc[7](loc3: u64)

22CopyLoc[0](Arg0: &mut SystemStateInnerV1)

23MutBorrowField[3](SystemStateInnerV1.used_capacity_size: u64)

24WriteRef

B4:

25MoveLoc[7](loc3: u64)

26CopyLoc[0](Arg0: &mut SystemStateInnerV1)

27ImmBorrowField[4](SystemStateInnerV1.total_capacity_size: u64)

28ReadRef

29Le

30BrFalse(32)

B5:

31Branch(36)

B6:

32MoveLoc[0](Arg0: &mut SystemStateInnerV1)

33Pop

34LdConst[3](u64: 1)

35Abort

B7:

36MoveLoc[4](loc0: u32)

37LdU32(1)

38Add

39StLoc[4](loc0: u32)

40Branch(4)

B8:

41MoveLoc[0](Arg0: &mut SystemStateInnerV1)

42Pop

43Ret

}

Constants [

0 => u32: 1000

1 => u64: 1048576

2 => u64: 0

3 => u64: 1

4 => u64: 2

5 => u64: 3

6 => u64: 4

7 => u64: 5

8 => u64: 6

9 => u64: 7

10 => u64: 8

11 => u64: 9

12 => u64: 10

13 => u64: 11

14 => u64: 12

15 => vector<u128>: 00

]

}