staking_inner
Module0xfa65…814e
- Move path
- 0xfdc8…ea77::staking_inner
- Functions
- 470 public, 0 entry
- Structs
- 2
- Friend modules
- staking
staking_inner
- active_set11
- apportionment_queue6
- auth5
- blob27
- bls_aggregate16
- committee9
- display4
- encoding1
- epoch_parameters4
- event_blob15
- events16
- extended_field5
- init3
- messages29
- metadata4
- node_metadata10
- pending_values10
- pool_exchange_rate4
- redstuff7
- shared_blob6
- sort0
- staked_wal12
- staking39
- staking_inner47
- staking_pool38
- storage_accounting13
- storage_node21
- storage_resource11
- system28
- system_state_inner26
- upgrade9
- walrus_context4
Bytecode2835 lines
The on-chain disassembly. Offsets are instruction numbers within each function.
// Move bytecode v7
module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.staking_inner {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::u128;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000001::uq64_64;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::bls12381;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::group_ops;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::object_table;
use 0000000000000000000000000000000000000000000000000000000000000002::priority_queue;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::active_set;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::apportionment_queue;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::auth;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::bls_aggregate;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::committee;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::epoch_parameters;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::extended_field;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::node_metadata;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::staked_wal;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::staking_pool;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_node;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::walrus_context;
struct StakingInnerV1 has store {
n_shards: u16,
epoch_duration: u64,
first_epoch_start: u64,
pools: ObjectTable<ID, StakingPool>,
epoch: u32,
active_set: ExtendedField<ActiveSet>,
next_committee: Option<Committee>,
committee: Committee,
previous_committee: Committee,
next_epoch_params: Option<EpochParams>,
epoch_state: EpochState,
next_epoch_public_keys: ExtendedField<VecMap<ID, Element<UncompressedG1>>>
}
enum EpochState has copy, drop, store {
EpochChangeSync { pos0: u16 },
EpochChangeDone { pos0: u64 },
NextParamsSelected { pos0: u64 }
}
is_next_params_selected(Arg0: &EpochState): bool {
L1: loc0: bool
L2: loc1: &EpochState
B0:
0MoveLoc[0](Arg0: &EpochState)
1StLoc[2](loc1: &EpochState)
2CopyLoc[2](loc1: &EpochState)
3VariantSwitch(VariantJumpTableIndex(0))
B1:
4MoveLoc[2](loc1: &EpochState)
5Pop
6LdFalse
7StLoc[1](loc0: bool)
8Branch(19)
B2:
9MoveLoc[2](loc1: &EpochState)
10Pop
11LdFalse
12StLoc[1](loc0: bool)
13Branch(19)
B3:
14MoveLoc[2](loc1: &EpochState)
15UnpackVariantImmRef(VariantHandleIndex(0))
16Pop
17LdTrue
18StLoc[1](loc0: bool)
B4:
19MoveLoc[1](loc0: bool)
20Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 4
Variant1 => jump 9
Variant2 => jump 14
}
}
public(friend) new(Arg0: u64, Arg1: u64, Arg2: u16, Arg3: &Clock, Arg4: &mut TxContext): StakingInnerV1 {
B0:
0MoveLoc[2](Arg2: u16)
1MoveLoc[1](Arg1: u64)
2MoveLoc[0](Arg0: u64)
3CopyLoc[3](Arg3: &Clock)
4Call clock::timestamp_ms(&Clock): u64
5Add
6CopyLoc[4](Arg4: &mut TxContext)
7Call object_table::new<ID, StakingPool>(&mut TxContext): ObjectTable<ID, StakingPool>
8LdU32(0)
9LdConst[1](u16: 150)
10LdConst[0](u64: 0)
11Call active_set::new(u16, u64): ActiveSet
12CopyLoc[4](Arg4: &mut TxContext)
13Call extended_field::new<ActiveSet>(ActiveSet, &mut TxContext): ExtendedField<ActiveSet>
14Call option::none<Committee>(): Option<Committee>
15Call committee::empty(): Committee
16Call committee::empty(): Committee
17Call option::none<EpochParams>(): Option<EpochParams>
18MoveLoc[3](Arg3: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20PackVariant(VariantHandleIndex(1))
21Call vec_map::empty<ID, Element<UncompressedG1>>(): VecMap<ID, Element<UncompressedG1>>
22MoveLoc[4](Arg4: &mut TxContext)
23Call extended_field::new<VecMap<ID, Element<UncompressedG1>>>(VecMap<ID, Element<UncompressedG1>>, &mut TxContext): ExtendedField<VecMap<ID, Element<UncompressedG1>>>
24Pack[0](StakingInnerV1)
25Ret
}
public(friend) create_pool(Arg0: &mut StakingInnerV1, Arg1: String, Arg2: String, Arg3: NodeMetadata, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: u16, Arg8: u64, Arg9: u64, Arg10: u64, Arg11: &mut TxContext): ID {
L12: loc0: WalrusContext
L13: loc1: String
L14: loc2: String
L15: loc3: u64
L16: loc4: u64
L17: loc5: u64
L18: loc6: u16
L19: loc7: vector<u8>
L20: loc8: vector<u8>
L21: loc9: vector<u8>
L22: loc10: NodeMetadata
L23: loc11: ID
L24: loc12: StakingPool
B0:
0MoveLoc[1](Arg1: String)
1StLoc[14](loc2: String)
2MoveLoc[2](Arg2: String)
3StLoc[13](loc1: String)
4MoveLoc[3](Arg3: NodeMetadata)
5StLoc[22](loc10: NodeMetadata)
6MoveLoc[4](Arg4: vector<u8>)
7StLoc[21](loc9: vector<u8>)
8MoveLoc[5](Arg5: vector<u8>)
9StLoc[20](loc8: vector<u8>)
10MoveLoc[6](Arg6: vector<u8>)
11StLoc[19](loc7: vector<u8>)
12MoveLoc[7](Arg7: u16)
13StLoc[18](loc6: u16)
14MoveLoc[8](Arg8: u64)
15StLoc[17](loc5: u64)
16MoveLoc[9](Arg9: u64)
17StLoc[16](loc4: u64)
18MoveLoc[10](Arg10: u64)
19StLoc[15](loc3: u64)
20CopyLoc[0](Arg0: &mut StakingInnerV1)
21FreezeRef
22Call new_walrus_context(&StakingInnerV1): WalrusContext
23StLoc[12](loc0: WalrusContext)
24MoveLoc[14](loc2: String)
25MoveLoc[13](loc1: String)
26MoveLoc[22](loc10: NodeMetadata)
27MoveLoc[21](loc9: vector<u8>)
28MoveLoc[20](loc8: vector<u8>)
29MoveLoc[19](loc7: vector<u8>)
30MoveLoc[18](loc6: u16)
31MoveLoc[17](loc5: u64)
32MoveLoc[16](loc4: u64)
33MoveLoc[15](loc3: u64)
34ImmBorrowLoc[12](loc0: WalrusContext)
35MoveLoc[11](Arg11: &mut TxContext)
36Call staking_pool::new(String, String, NodeMetadata, vector<u8>, vector<u8>, vector<u8>, u16, u64, u64, u64, &WalrusContext, &mut TxContext): StakingPool
37StLoc[24](loc12: StakingPool)
38ImmBorrowLoc[24](loc12: StakingPool)
39Call object::id<StakingPool>(&StakingPool): ID
40StLoc[23](loc11: ID)
41MoveLoc[0](Arg0: &mut StakingInnerV1)
42MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
43CopyLoc[23](loc11: ID)
44MoveLoc[24](loc12: StakingPool)
45Call object_table::add<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID, StakingPool)
46MoveLoc[23](loc11: ID)
47Ret
}
public(friend) set_commission_receiver(Arg0: &mut StakingInnerV1, Arg1: ID, Arg2: Authenticated, Arg3: Authorized) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
4MoveLoc[2](Arg2: Authenticated)
5MoveLoc[3](Arg3: Authorized)
6Call staking_pool::set_commission_receiver(&mut StakingPool, Authenticated, Authorized)
7Ret
}
public(friend) collect_commission(Arg0: &mut StakingInnerV1, Arg1: ID, Arg2: Authenticated): Balance<WAL> {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
4MoveLoc[2](Arg2: Authenticated)
5Call staking_pool::collect_commission(&mut StakingPool, Authenticated): Balance<WAL>
6Ret
}
public(friend) voting_end(Arg0: &mut StakingInnerV1, Arg1: &Clock) {
L2: loc0: &EpochState
L3: loc1: EpochState
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
2ReadRef
3StLoc[3](loc1: EpochState)
4ImmBorrowLoc[3](loc1: EpochState)
5StLoc[2](loc0: &EpochState)
6CopyLoc[2](loc0: &EpochState)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[0](Arg0: &mut StakingInnerV1)
9Pop
10MoveLoc[1](Arg1: &Clock)
11Pop
12MoveLoc[2](loc0: &EpochState)
13Pop
14LdConst[0](u64: 0)
15Abort
B2:
16MoveLoc[0](Arg0: &mut StakingInnerV1)
17Pop
18MoveLoc[1](Arg1: &Clock)
19Pop
20MoveLoc[2](loc0: &EpochState)
21Pop
22LdConst[0](u64: 0)
23Abort
B3:
24MoveLoc[2](loc0: &EpochState)
25UnpackVariantImmRef(VariantHandleIndex(1))
26Pop
27MoveLoc[3](loc1: EpochState)
28UnpackVariant(VariantHandleIndex(1))
29StLoc[4](loc2: u64)
30MoveLoc[1](Arg1: &Clock)
31Call clock::timestamp_ms(&Clock): u64
32StLoc[5](loc3: u64)
33CopyLoc[0](Arg0: &mut StakingInnerV1)
34ImmBorrowField[2](StakingInnerV1.epoch_duration: u64)
35ReadRef
36LdU64(2)
37Div
38StLoc[6](loc4: u64)
39CopyLoc[0](Arg0: &mut StakingInnerV1)
40ImmBorrowField[3](StakingInnerV1.epoch: u32)
41ReadRef
42LdU32(0)
43Neq
44BrFalse(56)
B4:
45MoveLoc[5](loc3: u64)
46CopyLoc[4](loc2: u64)
47MoveLoc[6](loc4: u64)
48Add
49Ge
50BrFalse(52)
B5:
51Branch(67)
B6:
52MoveLoc[0](Arg0: &mut StakingInnerV1)
53Pop
54LdConst[0](u64: 0)
55Abort
B7:
56MoveLoc[5](loc3: u64)
57CopyLoc[0](Arg0: &mut StakingInnerV1)
58ImmBorrowField[4](StakingInnerV1.first_epoch_start: u64)
59ReadRef
60Ge
61BrFalse(63)
B8:
62Branch(67)
B9:
63MoveLoc[0](Arg0: &mut StakingInnerV1)
64Pop
65LdConst[0](u64: 0)
66Abort
B10:
67CopyLoc[0](Arg0: &mut StakingInnerV1)
68Call clear_previous_committee_blocked_commission(&mut StakingInnerV1)
69CopyLoc[0](Arg0: &mut StakingInnerV1)
70Call select_committee_and_calculate_votes(&mut StakingInnerV1)
71MoveLoc[4](loc2: u64)
72PackVariant(VariantHandleIndex(0))
73CopyLoc[0](Arg0: &mut StakingInnerV1)
74MutBorrowField[1](StakingInnerV1.epoch_state: EpochState)
75WriteRef
76MoveLoc[0](Arg0: &mut StakingInnerV1)
77ImmBorrowField[3](StakingInnerV1.epoch: u32)
78ReadRef
79LdU32(1)
80Add
81Call events::emit_epoch_parameters_selected(u32)
82Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 8
Variant1 => jump 24
Variant2 => jump 16
}
}
clear_previous_committee_blocked_commission(Arg0: &mut StakingInnerV1) {
L1: loc0: u64
L2: loc1: u64
L3: loc2: ID
L4: loc3: u64
L5: loc4: vector<ID>
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[5](StakingInnerV1.previous_committee: Committee)
2Call committee::inner(&Committee): &VecMap<ID, vector<u16>>
3ReadRef
4Call vec_map::into_keys_values<ID, vector<u16>>(VecMap<ID, vector<u16>>): vector<ID> * vector<vector<u16>>
5Pop
6StLoc[5](loc4: vector<ID>)
7MutBorrowLoc[5](loc4: vector<ID>)
8Call vector::reverse<ID>(&mut vector<ID>)
9ImmBorrowLoc[5](loc4: vector<ID>)
10VecLen(5)
11StLoc[1](loc0: u64)
12LdU64(0)
13StLoc[2](loc1: u64)
14MoveLoc[1](loc0: u64)
15StLoc[4](loc3: u64)
B1:
16CopyLoc[2](loc1: u64)
17CopyLoc[4](loc3: u64)
18Lt
19BrFalse(40)
B2:
20CopyLoc[2](loc1: u64)
21Pop
22MutBorrowLoc[5](loc4: vector<ID>)
23VecPopBack(5)
24StLoc[3](loc2: ID)
25CopyLoc[0](Arg0: &mut StakingInnerV1)
26ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
27CopyLoc[3](loc2: ID)
28Call object_table::contains<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): bool
29BrFalse(35)
B3:
30CopyLoc[0](Arg0: &mut StakingInnerV1)
31MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
32MoveLoc[3](loc2: ID)
33Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
34Call staking_pool::clear_blocked_commission(&mut StakingPool)
B4:
35MoveLoc[2](loc1: u64)
36LdU64(1)
37Add
38StLoc[2](loc1: u64)
39Branch(16)
B5:
40MoveLoc[0](Arg0: &mut StakingInnerV1)
41Pop
42MoveLoc[5](loc4: vector<ID>)
43VecUnpack(5, 0)
44Ret
}
public(friend) select_committee_and_calculate_votes(Arg0: &mut StakingInnerV1) {
L1: loc0: u64
L2: loc1: u64
L3: loc2: PriorityQueue<u64>
L4: loc3: Committee
L5: loc4: u64
L6: loc5: ID
L7: loc6: u64
L8: loc7: vector<ID>
L9: loc8: &StakingPool
L10: loc9: vector<Element<UncompressedG1>>
L11: loc10: VecMap<ID, Element<UncompressedG1>>
L12: loc11: vector<vector<u16>>
L13: loc12: u64
L14: loc13: u64
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
2Call option::is_none<Committee>(&Option<Committee>): bool
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut StakingInnerV1)
6Pop
7LdConst[8](u64: 5)
8Abort
B3:
9CopyLoc[0](Arg0: &mut StakingInnerV1)
10FreezeRef
11Call compute_next_committee(&StakingInnerV1): Committee
12StLoc[4](loc3: Committee)
13VecPack(84, 0)
14StLoc[10](loc9: vector<Element<UncompressedG1>>)
15ImmBorrowLoc[4](loc3: Committee)
16Call committee::inner(&Committee): &VecMap<ID, vector<u16>>
17ReadRef
18Call vec_map::into_keys_values<ID, vector<u16>>(VecMap<ID, vector<u16>>): vector<ID> * vector<vector<u16>>
19StLoc[12](loc11: vector<vector<u16>>)
20StLoc[8](loc7: vector<ID>)
21VecPack(85, 0)
22Call priority_queue::new<u64>(vector<Entry<u64>>): PriorityQueue<u64>
23StLoc[3](loc2: PriorityQueue<u64>)
24ImmBorrowLoc[8](loc7: vector<ID>)
25VecLen(5)
26StLoc[1](loc0: u64)
27LdU64(0)
28StLoc[5](loc4: u64)
29MoveLoc[1](loc0: u64)
30StLoc[13](loc12: u64)
B4:
31CopyLoc[5](loc4: u64)
32CopyLoc[13](loc12: u64)
33Lt
34BrFalse(93)
B5:
35CopyLoc[5](loc4: u64)
36StLoc[7](loc6: u64)
37ImmBorrowLoc[8](loc7: vector<ID>)
38CopyLoc[7](loc6: u64)
39VecImmBorrow(5)
40ReadRef
41StLoc[6](loc5: ID)
42CopyLoc[0](Arg0: &mut StakingInnerV1)
43ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
44MoveLoc[6](loc5: ID)
45Call object_table::borrow<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): &StakingPool
46StLoc[9](loc8: &StakingPool)
47ImmBorrowLoc[12](loc11: vector<vector<u16>>)
48MoveLoc[7](loc6: u64)
49VecImmBorrow(35)
50VecLen(16)
51StLoc[14](loc13: u64)
52CopyLoc[14](loc13: u64)
53LdU64(0)
54Gt
55BrFalse(57)
B6:
56Branch(63)
B7:
57MoveLoc[0](Arg0: &mut StakingInnerV1)
58Pop
59MoveLoc[9](loc8: &StakingPool)
60Pop
61LdConst[12](u64: 9)
62Abort
B8:
63MutBorrowLoc[10](loc9: vector<Element<UncompressedG1>>)
64CopyLoc[9](loc8: &StakingPool)
65Call staking_pool::node_info(&StakingPool): &StorageNodeInfo
66Call storage_node::next_epoch_public_key(&StorageNodeInfo): &Element<UncompressedG1>
67ReadRef
68VecPushBack(84)
69MoveLoc[9](loc8: &StakingPool)
70Call staking_pool::node_capacity(&StakingPool): u64
71CastU128
72CopyLoc[0](Arg0: &mut StakingInnerV1)
73ImmBorrowField[7](StakingInnerV1.n_shards: u16)
74ReadRef
75CastU128
76Mul
77CopyLoc[14](loc13: u64)
78CastU128
79Div
80LdU128(18446744073709551615)
81Call u128::min(u128, u128): u128
82CastU64
83StLoc[2](loc1: u64)
84MutBorrowLoc[3](loc2: PriorityQueue<u64>)
85MoveLoc[2](loc1: u64)
86MoveLoc[14](loc13: u64)
87Call priority_queue::insert<u64>(&mut PriorityQueue<u64>, u64, u64)
88MoveLoc[5](loc4: u64)
89LdU64(1)
90Add
91StLoc[5](loc4: u64)
92Branch(31)
B9:
93MoveLoc[8](loc7: vector<ID>)
94MoveLoc[10](loc9: vector<Element<UncompressedG1>>)
95Call vec_map::from_keys_values<ID, Element<UncompressedG1>>(vector<ID>, vector<Element<UncompressedG1>>): VecMap<ID, Element<UncompressedG1>>
96StLoc[11](loc10: VecMap<ID, Element<UncompressedG1>>)
97CopyLoc[0](Arg0: &mut StakingInnerV1)
98MutBorrowField[8](StakingInnerV1.next_epoch_public_keys: ExtendedField<VecMap<ID, Element<UncompressedG1>>>)
99MoveLoc[11](loc10: VecMap<ID, Element<UncompressedG1>>)
100Call extended_field::swap<VecMap<ID, Element<UncompressedG1>>>(&mut ExtendedField<VecMap<ID, Element<UncompressedG1>>>, VecMap<ID, Element<UncompressedG1>>): VecMap<ID, Element<UncompressedG1>>
101Pop
102MoveLoc[4](loc3: Committee)
103Call option::some<Committee>(Committee): Option<Committee>
104CopyLoc[0](Arg0: &mut StakingInnerV1)
105MutBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
106WriteRef
107MutBorrowLoc[3](loc2: PriorityQueue<u64>)
108CopyLoc[0](Arg0: &mut StakingInnerV1)
109ImmBorrowField[7](StakingInnerV1.n_shards: u16)
110ReadRef
111Call quorum_above(&mut PriorityQueue<u64>, u16): u64
112LdU64(18446744073709551615)
113LdU64(18446744073709551615)
114Call epoch_parameters::new(u64, u64, u64): EpochParams
115Call option::some<EpochParams>(EpochParams): Option<EpochParams>
116MoveLoc[0](Arg0: &mut StakingInnerV1)
117MutBorrowField[9](StakingInnerV1.next_epoch_params: Option<EpochParams>)
118WriteRef
119Ret
}
quorum_above(Arg0: &mut PriorityQueue<u64>, Arg1: u16): u64 {
L2: loc0: u64
L3: loc1: u64
L4: loc2: u64
B0:
0LdU64(0)
1StLoc[2](loc0: u64)
B1:
2CopyLoc[0](Arg0: &mut PriorityQueue<u64>)
3Call priority_queue::pop_max<u64>(&mut PriorityQueue<u64>): u64 * u64
4StLoc[4](loc2: u64)
5StLoc[3](loc1: u64)
6MoveLoc[2](loc0: u64)
7MoveLoc[4](loc2: u64)
8Add
9StLoc[2](loc0: u64)
10CopyLoc[2](loc0: u64)
11CopyLoc[1](Arg1: u16)
12CastU64
13Call is_quorum_for_n_shards(u64, u64): bool
14BrFalse(2)
B2:
15Branch(16)
B3:
16MoveLoc[0](Arg0: &mut PriorityQueue<u64>)
17Pop
18MoveLoc[3](loc1: u64)
19Ret
}
quorum_below(Arg0: &mut PriorityQueue<u64>, Arg1: u16): u64 {
L2: loc0: u64
L3: loc1: u64
L4: loc2: u64
B0:
0CopyLoc[1](Arg1: u16)
1CastU64
2StLoc[2](loc0: u64)
B1:
3CopyLoc[0](Arg0: &mut PriorityQueue<u64>)
4Call priority_queue::pop_max<u64>(&mut PriorityQueue<u64>): u64 * u64
5StLoc[4](loc2: u64)
6StLoc[3](loc1: u64)
7MoveLoc[2](loc0: u64)
8MoveLoc[4](loc2: u64)
9Sub
10StLoc[2](loc0: u64)
11CopyLoc[2](loc0: u64)
12CopyLoc[1](Arg1: u16)
13CastU64
14Call is_quorum_for_n_shards(u64, u64): bool
15Not
16BrFalse(3)
B2:
17Branch(18)
B3:
18MoveLoc[0](Arg0: &mut PriorityQueue<u64>)
19Pop
20MoveLoc[3](loc1: u64)
21Ret
}
public(friend) set_governance_authorized(Arg0: &mut StakingInnerV1, Arg1: ID, Arg2: Authenticated, Arg3: Authorized) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
4MoveLoc[2](Arg2: Authenticated)
5MoveLoc[3](Arg3: Authorized)
6Call staking_pool::set_governance_authorized(&mut StakingPool, Authenticated, Authorized)
7Ret
}
public(friend) check_governance_authorization(Arg0: &StakingInnerV1, Arg1: ID, Arg2: Authenticated): bool {
B0:
0ImmBorrowLoc[2](Arg2: Authenticated)
1MoveLoc[0](Arg0: &StakingInnerV1)
2ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
3MoveLoc[1](Arg1: ID)
4Call object_table::borrow<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): &StakingPool
5Call staking_pool::governance_authorized(&StakingPool): &Authorized
6Call auth::matches(&Authenticated, &Authorized): bool
7Ret
}
public(friend) get_current_node_weight(Arg0: &StakingInnerV1, Arg1: ID): u16 {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[10](StakingInnerV1.committee: Committee)
2Call committee::inner(&Committee): &VecMap<ID, vector<u16>>
3ImmBorrowLoc[1](Arg1: ID)
4Call vec_map::contains<ID, vector<u16>>(&VecMap<ID, vector<u16>>, &ID): bool
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &StakingInnerV1)
8Pop
9LdConst[7](u64: 4)
10Abort
B3:
11MoveLoc[0](Arg0: &StakingInnerV1)
12ImmBorrowField[10](StakingInnerV1.committee: Committee)
13ImmBorrowLoc[1](Arg1: ID)
14Call committee::shards(&Committee, &ID): &vector<u16>
15VecLen(16)
16StLoc[2](loc0: u64)
17CopyLoc[2](loc0: u64)
18LdU64(65535)
19Le
20BrFalse(22)
B4:
21Branch(24)
B5:
22LdConst[10](u64: 7)
23Abort
B6:
24MoveLoc[2](loc0: u64)
25CastU16
26Ret
}
public(friend) set_next_commission(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: u16) {
L3: loc0: WalrusContext
L4: loc1: &WalrusContext
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1FreezeRef
2Call new_walrus_context(&StakingInnerV1): WalrusContext
3StLoc[3](loc0: WalrusContext)
4ImmBorrowLoc[3](loc0: WalrusContext)
5StLoc[4](loc1: &WalrusContext)
6MoveLoc[0](Arg0: &mut StakingInnerV1)
7MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
8MoveLoc[1](Arg1: &StorageNodeCap)
9Call storage_node::node_id(&StorageNodeCap): ID
10Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
11MoveLoc[2](Arg2: u16)
12MoveLoc[4](loc1: &WalrusContext)
13Call staking_pool::set_next_commission(&mut StakingPool, u16, &WalrusContext)
14Ret
}
public(friend) set_storage_price_vote(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: u64)
6Call staking_pool::set_next_storage_price(&mut StakingPool, u64)
7Ret
}
public(friend) set_write_price_vote(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: u64)
6Call staking_pool::set_next_write_price(&mut StakingPool, u64)
7Ret
}
public(friend) recalculate_prices(Arg0: &StakingInnerV1): u64 * u64 {
L1: loc0: u64
L2: loc1: u64
L3: loc2: u64
L4: loc3: &VecMap<ID, vector<u16>>
L5: loc4: u64
L6: loc5: u64
L7: loc6: &ID
L8: loc7: &StakingPool
L9: loc8: &vector<u16>
L10: loc9: u64
L11: loc10: u64
L12: loc11: PriorityQueue<u64>
L13: loc12: u64
L14: loc13: PriorityQueue<u64>
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[10](StakingInnerV1.committee: Committee)
2Call committee::inner(&Committee): &VecMap<ID, vector<u16>>
3StLoc[4](loc3: &VecMap<ID, vector<u16>>)
4CopyLoc[4](loc3: &VecMap<ID, vector<u16>>)
5Call vec_map::length<ID, vector<u16>>(&VecMap<ID, vector<u16>>): u64
6StLoc[10](loc9: u64)
7CopyLoc[10](loc9: u64)
8LdU64(0)
9Eq
10BrFalse(20)
B1:
11MoveLoc[0](Arg0: &StakingInnerV1)
12Pop
13MoveLoc[4](loc3: &VecMap<ID, vector<u16>>)
14Pop
15LdU64(18446744073709551615)
16LdU64(18446744073709551615)
17StLoc[3](loc2: u64)
18StLoc[2](loc1: u64)
19Branch(81)
B2:
20VecPack(85, 0)
21Call priority_queue::new<u64>(vector<Entry<u64>>): PriorityQueue<u64>
22StLoc[12](loc11: PriorityQueue<u64>)
23VecPack(85, 0)
24Call priority_queue::new<u64>(vector<Entry<u64>>): PriorityQueue<u64>
25StLoc[14](loc13: PriorityQueue<u64>)
26MoveLoc[10](loc9: u64)
27StLoc[1](loc0: u64)
28LdU64(0)
29StLoc[5](loc4: u64)
30MoveLoc[1](loc0: u64)
31StLoc[11](loc10: u64)
B3:
32CopyLoc[5](loc4: u64)
33CopyLoc[11](loc10: u64)
34Lt
35BrFalse(67)
B4:
36CopyLoc[5](loc4: u64)
37StLoc[6](loc5: u64)
38CopyLoc[4](loc3: &VecMap<ID, vector<u16>>)
39MoveLoc[6](loc5: u64)
40Call vec_map::get_entry_by_idx<ID, vector<u16>>(&VecMap<ID, vector<u16>>, u64): &ID * &vector<u16>
41StLoc[9](loc8: &vector<u16>)
42StLoc[7](loc6: &ID)
43MoveLoc[9](loc8: &vector<u16>)
44VecLen(16)
45StLoc[13](loc12: u64)
46CopyLoc[0](Arg0: &StakingInnerV1)
47ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
48MoveLoc[7](loc6: &ID)
49ReadRef
50Call object_table::borrow<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): &StakingPool
51StLoc[8](loc7: &StakingPool)
52MutBorrowLoc[12](loc11: PriorityQueue<u64>)
53CopyLoc[8](loc7: &StakingPool)
54Call staking_pool::storage_price(&StakingPool): u64
55CopyLoc[13](loc12: u64)
56Call priority_queue::insert<u64>(&mut PriorityQueue<u64>, u64, u64)
57MutBorrowLoc[14](loc13: PriorityQueue<u64>)
58MoveLoc[8](loc7: &StakingPool)
59Call staking_pool::write_price(&StakingPool): u64
60MoveLoc[13](loc12: u64)
61Call priority_queue::insert<u64>(&mut PriorityQueue<u64>, u64, u64)
62MoveLoc[5](loc4: u64)
63LdU64(1)
64Add
65StLoc[5](loc4: u64)
66Branch(32)
B5:
67MoveLoc[4](loc3: &VecMap<ID, vector<u16>>)
68Pop
69MutBorrowLoc[12](loc11: PriorityQueue<u64>)
70CopyLoc[0](Arg0: &StakingInnerV1)
71ImmBorrowField[7](StakingInnerV1.n_shards: u16)
72ReadRef
73Call quorum_below(&mut PriorityQueue<u64>, u16): u64
74MutBorrowLoc[14](loc13: PriorityQueue<u64>)
75MoveLoc[0](Arg0: &StakingInnerV1)
76ImmBorrowField[7](StakingInnerV1.n_shards: u16)
77ReadRef
78Call quorum_below(&mut PriorityQueue<u64>, u16): u64
79StLoc[3](loc2: u64)
80StLoc[2](loc1: u64)
B6:
81MoveLoc[2](loc1: u64)
82MoveLoc[3](loc2: u64)
83Ret
}
public(friend) set_node_capacity_vote(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: u64)
6Call staking_pool::set_next_node_capacity(&mut StakingPool, u64)
7Ret
}
public(friend) set_next_public_key(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: &TxContext) {
L5: loc0: WalrusContext
L6: loc1: &WalrusContext
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1FreezeRef
2Call new_walrus_context(&StakingInnerV1): WalrusContext
3StLoc[5](loc0: WalrusContext)
4ImmBorrowLoc[5](loc0: WalrusContext)
5StLoc[6](loc1: &WalrusContext)
6MoveLoc[0](Arg0: &mut StakingInnerV1)
7MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
8MoveLoc[1](Arg1: &StorageNodeCap)
9Call storage_node::node_id(&StorageNodeCap): ID
10Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
11MoveLoc[2](Arg2: vector<u8>)
12MoveLoc[3](Arg3: vector<u8>)
13MoveLoc[6](loc1: &WalrusContext)
14MoveLoc[4](Arg4: &TxContext)
15Call staking_pool::set_next_public_key(&mut StakingPool, vector<u8>, vector<u8>, &WalrusContext, &TxContext)
16Ret
}
public(friend) set_name(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: String) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: String)
6Call staking_pool::set_name(&mut StakingPool, String)
7Ret
}
public(friend) set_network_address(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: String) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: String)
6Call staking_pool::set_network_address(&mut StakingPool, String)
7Ret
}
public(friend) set_network_public_key(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: vector<u8>) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: vector<u8>)
6Call staking_pool::set_network_public_key(&mut StakingPool, vector<u8>)
7Ret
}
public(friend) set_node_metadata(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap, Arg2: NodeMetadata) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call storage_node::node_id(&StorageNodeCap): ID
4Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
5MoveLoc[2](Arg2: NodeMetadata)
6Call staking_pool::set_node_metadata(&mut StakingPool, NodeMetadata)
7Ret
}
public(friend) destroy_empty_pool(Arg0: &mut StakingInnerV1, Arg1: ID, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::remove<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): StakingPool
4Call staking_pool::destroy_empty(StakingPool)
5Ret
}
public(friend) stake_with_pool(Arg0: &mut StakingInnerV1, Arg1: Coin<WAL>, Arg2: ID, Arg3: &mut TxContext): StakedWal {
L4: loc0: WalrusContext
L5: loc1: u64
L6: loc2: &EpochState
L7: loc3: EpochState
L8: loc4: u64
L9: loc5: &mut StakingPool
L10: loc6: StakedWal
L11: loc7: &WalrusContext
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1FreezeRef
2Call new_walrus_context(&StakingInnerV1): WalrusContext
3StLoc[4](loc0: WalrusContext)
4ImmBorrowLoc[4](loc0: WalrusContext)
5StLoc[11](loc7: &WalrusContext)
6CopyLoc[0](Arg0: &mut StakingInnerV1)
7MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
8CopyLoc[2](Arg2: ID)
9Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
10StLoc[9](loc5: &mut StakingPool)
11CopyLoc[9](loc5: &mut StakingPool)
12MoveLoc[1](Arg1: Coin<WAL>)
13Call coin::into_balance<WAL>(Coin<WAL>): Balance<WAL>
14CopyLoc[11](loc7: &WalrusContext)
15MoveLoc[3](Arg3: &mut TxContext)
16Call staking_pool::stake(&mut StakingPool, Balance<WAL>, &WalrusContext, &mut TxContext): StakedWal
17StLoc[10](loc6: StakedWal)
18CopyLoc[0](Arg0: &mut StakingInnerV1)
19ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
20ReadRef
21StLoc[7](loc3: EpochState)
22ImmBorrowLoc[7](loc3: EpochState)
23StLoc[6](loc2: &EpochState)
24CopyLoc[6](loc2: &EpochState)
25VariantSwitch(VariantJumpTableIndex(0))
B1:
26MoveLoc[6](loc2: &EpochState)
27Pop
28MoveLoc[9](loc5: &mut StakingPool)
29FreezeRef
30MoveLoc[11](loc7: &WalrusContext)
31Call walrus_context::epoch(&WalrusContext): u32
32LdU32(1)
33Add
34Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
35StLoc[5](loc1: u64)
36Branch(62)
B2:
37MoveLoc[6](loc2: &EpochState)
38Pop
39MoveLoc[9](loc5: &mut StakingPool)
40FreezeRef
41MoveLoc[11](loc7: &WalrusContext)
42Call walrus_context::epoch(&WalrusContext): u32
43LdU32(1)
44Add
45Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
46StLoc[5](loc1: u64)
47Branch(62)
B3:
48MoveLoc[6](loc2: &EpochState)
49UnpackVariantImmRef(VariantHandleIndex(0))
50Pop
51MoveLoc[7](loc3: EpochState)
52UnpackVariant(VariantHandleIndex(0))
53Pop
54MoveLoc[9](loc5: &mut StakingPool)
55FreezeRef
56MoveLoc[11](loc7: &WalrusContext)
57Call walrus_context::epoch(&WalrusContext): u32
58LdU32(2)
59Add
60Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
61StLoc[5](loc1: u64)
B4:
62MoveLoc[5](loc1: u64)
63StLoc[8](loc4: u64)
64MoveLoc[0](Arg0: &mut StakingInnerV1)
65MutBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
66Call extended_field::borrow_mut<ActiveSet>(&mut ExtendedField<ActiveSet>): &mut ActiveSet
67MoveLoc[2](Arg2: ID)
68MoveLoc[8](loc4: u64)
69Call active_set::insert_or_update(&mut ActiveSet, ID, u64): bool
70Pop
71MoveLoc[10](loc6: StakedWal)
72Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 26
Variant1 => jump 37
Variant2 => jump 48
}
}
public(friend) request_withdraw_stake(Arg0: &mut StakingInnerV1, Arg1: &mut StakedWal, Arg2: &mut TxContext) {
L3: loc0: WalrusContext
L4: loc1: u64
L5: loc2: bool
L6: loc3: bool
L7: loc4: bool
L8: loc5: &mut StakedWal
L9: loc6: &mut StakingPool
L10: loc7: &EpochState
L11: loc8: EpochState
L12: loc9: u64
L13: loc10: ID
L14: loc11: &Option<Committee>
L15: loc12: &mut StakingPool
L16: loc13: &WalrusContext
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1FreezeRef
2Call new_walrus_context(&StakingInnerV1): WalrusContext
3StLoc[3](loc0: WalrusContext)
4ImmBorrowLoc[3](loc0: WalrusContext)
5StLoc[16](loc13: &WalrusContext)
6CopyLoc[1](Arg1: &mut StakedWal)
7FreezeRef
8Call staked_wal::node_id(&StakedWal): ID
9StLoc[13](loc10: ID)
10CopyLoc[0](Arg0: &mut StakingInnerV1)
11MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
12CopyLoc[13](loc10: ID)
13Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
14StLoc[15](loc12: &mut StakingPool)
15CopyLoc[15](loc12: &mut StakingPool)
16StLoc[9](loc6: &mut StakingPool)
17MoveLoc[1](Arg1: &mut StakedWal)
18StLoc[8](loc5: &mut StakedWal)
19CopyLoc[0](Arg0: &mut StakingInnerV1)
20ImmBorrowField[10](StakingInnerV1.committee: Committee)
21ImmBorrowLoc[13](loc10: ID)
22Call committee::contains(&Committee, &ID): bool
23StLoc[7](loc4: bool)
24CopyLoc[0](Arg0: &mut StakingInnerV1)
25ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
26StLoc[14](loc11: &Option<Committee>)
27CopyLoc[14](loc11: &Option<Committee>)
28Call option::is_some<Committee>(&Option<Committee>): bool
29BrFalse(36)
B1:
30MoveLoc[14](loc11: &Option<Committee>)
31Call option::borrow<Committee>(&Option<Committee>): &Committee
32ImmBorrowLoc[13](loc10: ID)
33Call committee::contains(&Committee, &ID): bool
34StLoc[6](loc3: bool)
35Branch(40)
B2:
36MoveLoc[14](loc11: &Option<Committee>)
37Pop
38LdFalse
39StLoc[6](loc3: bool)
B3:
40MoveLoc[6](loc3: bool)
41StLoc[5](loc2: bool)
42MoveLoc[9](loc6: &mut StakingPool)
43MoveLoc[8](loc5: &mut StakedWal)
44MoveLoc[7](loc4: bool)
45MoveLoc[5](loc2: bool)
46CopyLoc[16](loc13: &WalrusContext)
47Call staking_pool::request_withdraw_stake(&mut StakingPool, &mut StakedWal, bool, bool, &WalrusContext)
48CopyLoc[0](Arg0: &mut StakingInnerV1)
49ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
50ReadRef
51StLoc[11](loc8: EpochState)
52ImmBorrowLoc[11](loc8: EpochState)
53StLoc[10](loc7: &EpochState)
54CopyLoc[10](loc7: &EpochState)
55VariantSwitch(VariantJumpTableIndex(0))
B4:
56MoveLoc[10](loc7: &EpochState)
57Pop
58MoveLoc[15](loc12: &mut StakingPool)
59FreezeRef
60MoveLoc[16](loc13: &WalrusContext)
61Call walrus_context::epoch(&WalrusContext): u32
62LdU32(1)
63Add
64Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
65StLoc[4](loc1: u64)
66Branch(92)
B5:
67MoveLoc[10](loc7: &EpochState)
68Pop
69MoveLoc[15](loc12: &mut StakingPool)
70FreezeRef
71MoveLoc[16](loc13: &WalrusContext)
72Call walrus_context::epoch(&WalrusContext): u32
73LdU32(1)
74Add
75Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
76StLoc[4](loc1: u64)
77Branch(92)
B6:
78MoveLoc[10](loc7: &EpochState)
79UnpackVariantImmRef(VariantHandleIndex(0))
80Pop
81MoveLoc[11](loc8: EpochState)
82UnpackVariant(VariantHandleIndex(0))
83Pop
84MoveLoc[15](loc12: &mut StakingPool)
85FreezeRef
86MoveLoc[16](loc13: &WalrusContext)
87Call walrus_context::epoch(&WalrusContext): u32
88LdU32(2)
89Add
90Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
91StLoc[4](loc1: u64)
B7:
92MoveLoc[4](loc1: u64)
93StLoc[12](loc9: u64)
94MoveLoc[0](Arg0: &mut StakingInnerV1)
95MutBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
96Call extended_field::borrow_mut<ActiveSet>(&mut ExtendedField<ActiveSet>): &mut ActiveSet
97MoveLoc[13](loc10: ID)
98MoveLoc[12](loc9: u64)
99Call active_set::insert_or_update(&mut ActiveSet, ID, u64): bool
100Pop
101Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 56
Variant1 => jump 67
Variant2 => jump 78
}
}
public(friend) withdraw_stake(Arg0: &mut StakingInnerV1, Arg1: StakedWal, Arg2: &mut TxContext): Coin<WAL> {
L3: loc0: WalrusContext
L4: loc1: u64
L5: loc2: bool
L6: loc3: bool
L7: loc4: bool
L8: loc5: StakedWal
L9: loc6: &mut StakingPool
L10: loc7: &EpochState
L11: loc8: EpochState
L12: loc9: u64
L13: loc10: ID
L14: loc11: &Option<Committee>
L15: loc12: &mut StakingPool
L16: loc13: Balance<WAL>
L17: loc14: &WalrusContext
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1FreezeRef
2Call new_walrus_context(&StakingInnerV1): WalrusContext
3StLoc[3](loc0: WalrusContext)
4ImmBorrowLoc[3](loc0: WalrusContext)
5StLoc[17](loc14: &WalrusContext)
6ImmBorrowLoc[1](Arg1: StakedWal)
7Call staked_wal::node_id(&StakedWal): ID
8StLoc[13](loc10: ID)
9CopyLoc[0](Arg0: &mut StakingInnerV1)
10MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
11CopyLoc[13](loc10: ID)
12Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
13StLoc[15](loc12: &mut StakingPool)
14CopyLoc[15](loc12: &mut StakingPool)
15StLoc[9](loc6: &mut StakingPool)
16MoveLoc[1](Arg1: StakedWal)
17StLoc[8](loc5: StakedWal)
18CopyLoc[0](Arg0: &mut StakingInnerV1)
19ImmBorrowField[10](StakingInnerV1.committee: Committee)
20ImmBorrowLoc[13](loc10: ID)
21Call committee::contains(&Committee, &ID): bool
22StLoc[7](loc4: bool)
23CopyLoc[0](Arg0: &mut StakingInnerV1)
24ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
25StLoc[14](loc11: &Option<Committee>)
26CopyLoc[14](loc11: &Option<Committee>)
27Call option::is_some<Committee>(&Option<Committee>): bool
28BrFalse(35)
B1:
29MoveLoc[14](loc11: &Option<Committee>)
30Call option::borrow<Committee>(&Option<Committee>): &Committee
31ImmBorrowLoc[13](loc10: ID)
32Call committee::contains(&Committee, &ID): bool
33StLoc[6](loc3: bool)
34Branch(39)
B2:
35MoveLoc[14](loc11: &Option<Committee>)
36Pop
37LdFalse
38StLoc[6](loc3: bool)
B3:
39MoveLoc[6](loc3: bool)
40StLoc[5](loc2: bool)
41MoveLoc[9](loc6: &mut StakingPool)
42MoveLoc[8](loc5: StakedWal)
43MoveLoc[7](loc4: bool)
44MoveLoc[5](loc2: bool)
45CopyLoc[17](loc14: &WalrusContext)
46Call staking_pool::withdraw_stake(&mut StakingPool, StakedWal, bool, bool, &WalrusContext): Balance<WAL>
47StLoc[16](loc13: Balance<WAL>)
48CopyLoc[0](Arg0: &mut StakingInnerV1)
49ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
50ReadRef
51StLoc[11](loc8: EpochState)
52ImmBorrowLoc[11](loc8: EpochState)
53StLoc[10](loc7: &EpochState)
54CopyLoc[10](loc7: &EpochState)
55VariantSwitch(VariantJumpTableIndex(0))
B4:
56MoveLoc[10](loc7: &EpochState)
57Pop
58MoveLoc[15](loc12: &mut StakingPool)
59FreezeRef
60MoveLoc[17](loc14: &WalrusContext)
61Call walrus_context::epoch(&WalrusContext): u32
62LdU32(1)
63Add
64Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
65StLoc[4](loc1: u64)
66Branch(92)
B5:
67MoveLoc[10](loc7: &EpochState)
68Pop
69MoveLoc[15](loc12: &mut StakingPool)
70FreezeRef
71MoveLoc[17](loc14: &WalrusContext)
72Call walrus_context::epoch(&WalrusContext): u32
73LdU32(1)
74Add
75Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
76StLoc[4](loc1: u64)
77Branch(92)
B6:
78MoveLoc[10](loc7: &EpochState)
79UnpackVariantImmRef(VariantHandleIndex(0))
80Pop
81MoveLoc[11](loc8: EpochState)
82UnpackVariant(VariantHandleIndex(0))
83Pop
84MoveLoc[15](loc12: &mut StakingPool)
85FreezeRef
86MoveLoc[17](loc14: &WalrusContext)
87Call walrus_context::epoch(&WalrusContext): u32
88LdU32(2)
89Add
90Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
91StLoc[4](loc1: u64)
B7:
92MoveLoc[4](loc1: u64)
93StLoc[12](loc9: u64)
94MoveLoc[0](Arg0: &mut StakingInnerV1)
95MutBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
96Call extended_field::borrow_mut<ActiveSet>(&mut ExtendedField<ActiveSet>): &mut ActiveSet
97MoveLoc[13](loc10: ID)
98MoveLoc[12](loc9: u64)
99Call active_set::insert_or_update(&mut ActiveSet, ID, u64): bool
100Pop
101MoveLoc[16](loc13: Balance<WAL>)
102MoveLoc[2](Arg2: &mut TxContext)
103Call coin::from_balance<WAL>(Balance<WAL>, &mut TxContext): Coin<WAL>
104Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 56
Variant1 => jump 67
Variant2 => jump 78
}
}
public(friend) try_join_active_set(Arg0: &mut StakingInnerV1, Arg1: &StorageNodeCap) {
L2: loc0: WalrusContext
L3: loc1: u64
L4: loc2: &EpochState
L5: loc3: EpochState
L6: loc4: u64
L7: loc5: ID
L8: loc6: &StakingPool
L9: loc7: &WalrusContext
B0:
0MoveLoc[1](Arg1: &StorageNodeCap)
1Call storage_node::node_id(&StorageNodeCap): ID
2StLoc[7](loc5: ID)
3CopyLoc[0](Arg0: &mut StakingInnerV1)
4FreezeRef
5Call new_walrus_context(&StakingInnerV1): WalrusContext
6StLoc[2](loc0: WalrusContext)
7ImmBorrowLoc[2](loc0: WalrusContext)
8StLoc[9](loc7: &WalrusContext)
9CopyLoc[0](Arg0: &mut StakingInnerV1)
10ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
11CopyLoc[7](loc5: ID)
12Call object_table::borrow<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): &StakingPool
13StLoc[8](loc6: &StakingPool)
14CopyLoc[0](Arg0: &mut StakingInnerV1)
15ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
16ReadRef
17StLoc[5](loc3: EpochState)
18ImmBorrowLoc[5](loc3: EpochState)
19StLoc[4](loc2: &EpochState)
20CopyLoc[4](loc2: &EpochState)
21VariantSwitch(VariantJumpTableIndex(0))
B1:
22MoveLoc[4](loc2: &EpochState)
23Pop
24MoveLoc[8](loc6: &StakingPool)
25MoveLoc[9](loc7: &WalrusContext)
26Call walrus_context::epoch(&WalrusContext): u32
27LdU32(1)
28Add
29Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
30StLoc[3](loc1: u64)
31Branch(55)
B2:
32MoveLoc[4](loc2: &EpochState)
33Pop
34MoveLoc[8](loc6: &StakingPool)
35MoveLoc[9](loc7: &WalrusContext)
36Call walrus_context::epoch(&WalrusContext): u32
37LdU32(1)
38Add
39Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
40StLoc[3](loc1: u64)
41Branch(55)
B3:
42MoveLoc[4](loc2: &EpochState)
43UnpackVariantImmRef(VariantHandleIndex(0))
44Pop
45MoveLoc[5](loc3: EpochState)
46UnpackVariant(VariantHandleIndex(0))
47Pop
48MoveLoc[8](loc6: &StakingPool)
49MoveLoc[9](loc7: &WalrusContext)
50Call walrus_context::epoch(&WalrusContext): u32
51LdU32(2)
52Add
53Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
54StLoc[3](loc1: u64)
B4:
55MoveLoc[3](loc1: u64)
56StLoc[6](loc4: u64)
57MoveLoc[0](Arg0: &mut StakingInnerV1)
58MutBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
59Call extended_field::borrow_mut<ActiveSet>(&mut ExtendedField<ActiveSet>): &mut ActiveSet
60MoveLoc[7](loc5: ID)
61MoveLoc[6](loc4: u64)
62Call active_set::insert_or_update(&mut ActiveSet, ID, u64): bool
63Pop
64Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 22
Variant1 => jump 32
Variant2 => jump 42
}
}
public(friend) compute_next_committee(Arg0: &StakingInnerV1): Committee {
L1: loc0: Committee
L2: loc1: VecMap<ID, u16>
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1Call apportionment(&StakingInnerV1): VecMap<ID, u16>
2StLoc[2](loc1: VecMap<ID, u16>)
3CopyLoc[0](Arg0: &StakingInnerV1)
4ImmBorrowField[10](StakingInnerV1.committee: Committee)
5Call committee::size(&Committee): u64
6LdU64(0)
7Eq
8BrFalse(15)
B1:
9MoveLoc[0](Arg0: &StakingInnerV1)
10Pop
11MoveLoc[2](loc1: VecMap<ID, u16>)
12Call committee::initialize(VecMap<ID, u16>): Committee
13StLoc[1](loc0: Committee)
14Branch(20)
B2:
15MoveLoc[0](Arg0: &StakingInnerV1)
16ImmBorrowField[10](StakingInnerV1.committee: Committee)
17MoveLoc[2](loc1: VecMap<ID, u16>)
18Call committee::transition(&Committee, VecMap<ID, u16>): Committee
19StLoc[1](loc0: Committee)
B3:
20MoveLoc[1](loc0: Committee)
21Ret
}
apportionment(Arg0: &StakingInnerV1): VecMap<ID, u16> {
L1: loc0: u64
L2: loc1: u64
L3: loc2: u64
L4: loc3: &mut vector<u64>
L5: loc4: vector<ID>
L6: loc5: VecMap<ID, u16>
L7: loc6: u64
L8: loc7: u64
L9: loc8: u64
L10: loc9: u64
L11: loc10: ID
L12: loc11: u64
L13: loc12: vector<u16>
L14: loc13: u16
L15: loc14: vector<u64>
L16: loc15: u64
L17: loc16: u64
L18: loc17: vector<u64>
L19: loc18: vector<ID>
L20: loc19: vector<ID>
L21: loc20: vector<u16>
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
2Call extended_field::borrow<ActiveSet>(&ExtendedField<ActiveSet>): &ActiveSet
3Call active_set::active_ids_and_stake(&ActiveSet): vector<ID> * vector<u64>
4StLoc[15](loc14: vector<u64>)
5StLoc[5](loc4: vector<ID>)
6ImmBorrowLoc[15](loc14: vector<u64>)
7VecLen(13)
8StLoc[12](loc11: u64)
9LdConst[14](vector<u64>: 00)
10StLoc[18](loc17: vector<u64>)
11CopyLoc[12](loc11: u64)
12StLoc[2](loc1: u64)
13LdU64(0)
14StLoc[10](loc9: u64)
15MoveLoc[2](loc1: u64)
16StLoc[17](loc16: u64)
B1:
17CopyLoc[10](loc9: u64)
18CopyLoc[17](loc16: u64)
19Lt
20BrFalse(39)
B2:
21CopyLoc[10](loc9: u64)
22StLoc[7](loc6: u64)
23MutBorrowLoc[18](loc17: vector<u64>)
24StLoc[4](loc3: &mut vector<u64>)
25MoveLoc[7](loc6: u64)
26StLoc[8](loc7: u64)
27CopyLoc[12](loc11: u64)
28MoveLoc[8](loc7: u64)
29Sub
30StLoc[3](loc2: u64)
31MoveLoc[4](loc3: &mut vector<u64>)
32MoveLoc[3](loc2: u64)
33VecPushBack(13)
34MoveLoc[10](loc9: u64)
35LdU64(1)
36Add
37StLoc[10](loc9: u64)
38Branch(17)
B3:
39MoveLoc[18](loc17: vector<u64>)
40MoveLoc[0](Arg0: &StakingInnerV1)
41ImmBorrowField[7](StakingInnerV1.n_shards: u16)
42ReadRef
43MoveLoc[15](loc14: vector<u64>)
44Call dhondt(vector<u64>, u16, vector<u64>): vector<u16>
45StLoc[13](loc12: vector<u16>)
46Call vec_map::empty<ID, u16>(): VecMap<ID, u16>
47StLoc[6](loc5: VecMap<ID, u16>)
48MoveLoc[5](loc4: vector<ID>)
49StLoc[20](loc19: vector<ID>)
50MoveLoc[13](loc12: vector<u16>)
51StLoc[21](loc20: vector<u16>)
52MutBorrowLoc[21](loc20: vector<u16>)
53Call vector::reverse<u16>(&mut vector<u16>)
54ImmBorrowLoc[20](loc19: vector<ID>)
55VecLen(5)
56ImmBorrowLoc[21](loc20: vector<u16>)
57VecLen(16)
58Eq
59BrFalse(61)
B4:
60Branch(63)
B5:
61LdU64(13906836785683496959)
62Abort
B6:
63MoveLoc[20](loc19: vector<ID>)
64StLoc[19](loc18: vector<ID>)
65MutBorrowLoc[19](loc18: vector<ID>)
66Call vector::reverse<ID>(&mut vector<ID>)
67ImmBorrowLoc[19](loc18: vector<ID>)
68VecLen(5)
69StLoc[1](loc0: u64)
70LdU64(0)
71StLoc[9](loc8: u64)
72MoveLoc[1](loc0: u64)
73StLoc[16](loc15: u64)
74Branch(75)
B7:
75CopyLoc[9](loc8: u64)
76CopyLoc[16](loc15: u64)
77Lt
78BrFalse(100)
B8:
79CopyLoc[9](loc8: u64)
80Pop
81MutBorrowLoc[19](loc18: vector<ID>)
82VecPopBack(5)
83StLoc[11](loc10: ID)
84MutBorrowLoc[21](loc20: vector<u16>)
85VecPopBack(16)
86StLoc[14](loc13: u16)
87CopyLoc[14](loc13: u16)
88LdU16(0)
89Gt
90BrFalse(95)
B9:
91MutBorrowLoc[6](loc5: VecMap<ID, u16>)
92MoveLoc[11](loc10: ID)
93MoveLoc[14](loc13: u16)
94Call vec_map::insert<ID, u16>(&mut VecMap<ID, u16>, ID, u16)
B10:
95MoveLoc[9](loc8: u64)
96LdU64(1)
97Add
98StLoc[9](loc8: u64)
99Branch(75)
B11:
100MoveLoc[19](loc18: vector<ID>)
101VecUnpack(5, 0)
102MoveLoc[21](loc20: vector<u16>)
103VecUnpack(16, 0)
104MoveLoc[6](loc5: VecMap<ID, u16>)
105Ret
}
dhondt(Arg0: vector<u64>, Arg1: u16, Arg2: vector<u64>): vector<u16> {
L3: loc0: u64
L4: loc1: u64
L5: loc2: u64
L6: loc3: u64
L7: loc4: u64
L8: loc5: &mut vector<u16>
L9: loc6: u64
L10: loc7: &mut vector<u64>
L11: loc8: u16
L12: loc9: u64
L13: loc10: u64
L14: loc11: u64
L15: loc12: u64
L16: loc13: u64
L17: loc14: &u64
L18: loc15: u64
L19: loc16: u64
L20: loc17: u64
L21: loc18: u64
L22: loc19: u64
L23: loc20: u64
L24: loc21: u64
L25: loc22: u64
L26: loc23: u64
L27: loc24: u64
L28: loc25: u64
L29: loc26: u64
L30: loc27: u64
L31: loc28: u64
L32: loc29: UQ64_64
L33: loc30: UQ64_64
L34: loc31: ApportionmentQueue<u64>
L35: loc32: vector<u64>
L36: loc33: vector<u16>
L37: loc34: vector<u64>
L38: loc35: u64
L39: loc36: u64
L40: loc37: u64
L41: loc38: u64
L42: loc39: u64
L43: loc40: u64
L44: loc41: u64
L45: loc42: vector<u64>
L46: loc43: &vector<u64>
L47: loc44: &vector<u64>
L48: loc45: vector<u64>
L49: loc46: vector<u64>
L50: loc47: vector<u64>
L51: loc48: vector<u64>
L52: loc49: vector<u64>
L53: loc50: u64
L54: loc51: u64
B0:
0CopyLoc[2](Arg2: vector<u64>)
1StLoc[45](loc42: vector<u64>)
2LdU64(0)
3StLoc[12](loc9: u64)
4MoveLoc[45](loc42: vector<u64>)
5StLoc[49](loc46: vector<u64>)
6MutBorrowLoc[49](loc46: vector<u64>)
7Call vector::reverse<u64>(&mut vector<u64>)
8ImmBorrowLoc[49](loc46: vector<u64>)
9VecLen(13)
10StLoc[7](loc4: u64)
11LdU64(0)
12StLoc[20](loc17: u64)
13MoveLoc[7](loc4: u64)
14StLoc[38](loc35: u64)
B1:
15CopyLoc[20](loc17: u64)
16CopyLoc[38](loc35: u64)
17Lt
18BrFalse(37)
B2:
19CopyLoc[20](loc17: u64)
20Pop
21MutBorrowLoc[49](loc46: vector<u64>)
22VecPopBack(13)
23StLoc[16](loc13: u64)
24MoveLoc[12](loc9: u64)
25StLoc[13](loc10: u64)
26MoveLoc[16](loc13: u64)
27StLoc[53](loc50: u64)
28MoveLoc[13](loc10: u64)
29MoveLoc[53](loc50: u64)
30Add
31StLoc[12](loc9: u64)
32MoveLoc[20](loc17: u64)
33LdU64(1)
34Add
35StLoc[20](loc17: u64)
36Branch(15)
B3:
37MoveLoc[49](loc46: vector<u64>)
38VecUnpack(13, 0)
39MoveLoc[12](loc9: u64)
40StLoc[44](loc41: u64)
41ImmBorrowLoc[2](Arg2: vector<u64>)
42VecLen(13)
43StLoc[29](loc26: u64)
44MoveLoc[1](Arg1: u16)
45CastU64
46StLoc[30](loc27: u64)
47CopyLoc[44](loc41: u64)
48LdU64(0)
49Gt
50BrFalse(52)
B4:
51Branch(54)
B5:
52LdConst[6](u64: 3)
53Abort
B6:
54CopyLoc[29](loc26: u64)
55CopyLoc[30](loc27: u64)
56Call max_shards_per_node(u64, u64): u64
57StLoc[28](loc25: u64)
58ImmBorrowLoc[2](Arg2: vector<u64>)
59StLoc[46](loc43: &vector<u64>)
60LdConst[14](vector<u64>: 00)
61StLoc[35](loc32: vector<u64>)
62MoveLoc[46](loc43: &vector<u64>)
63StLoc[47](loc44: &vector<u64>)
64CopyLoc[47](loc44: &vector<u64>)
65VecLen(13)
66StLoc[3](loc0: u64)
67LdU64(0)
68StLoc[21](loc18: u64)
69MoveLoc[3](loc0: u64)
70StLoc[39](loc36: u64)
B7:
71CopyLoc[21](loc18: u64)
72CopyLoc[39](loc36: u64)
73Lt
74BrFalse(105)
B8:
75Branch(76)
B9:
76CopyLoc[21](loc18: u64)
77StLoc[22](loc19: u64)
78CopyLoc[47](loc44: &vector<u64>)
79MoveLoc[22](loc19: u64)
80VecImmBorrow(13)
81StLoc[17](loc14: &u64)
82MutBorrowLoc[35](loc32: vector<u64>)
83StLoc[10](loc7: &mut vector<u64>)
84MoveLoc[17](loc14: &u64)
85ReadRef
86CopyLoc[44](loc41: u64)
87CopyLoc[30](loc27: u64)
88LdU64(1)
89Add
90Div
91LdU64(1)
92Add
93Div
94CopyLoc[28](loc25: u64)
95Call u64::min(u64, u64): u64
96StLoc[9](loc6: u64)
97MoveLoc[10](loc7: &mut vector<u64>)
98MoveLoc[9](loc6: u64)
99VecPushBack(13)
100MoveLoc[21](loc18: u64)
101LdU64(1)
102Add
103StLoc[21](loc18: u64)
104Branch(71)
B10:
105MoveLoc[47](loc44: &vector<u64>)
106Pop
107MoveLoc[35](loc32: vector<u64>)
108StLoc[37](loc34: vector<u64>)
109Call apportionment_queue::new<u64>(): ApportionmentQueue<u64>
110StLoc[34](loc31: ApportionmentQueue<u64>)
111CopyLoc[29](loc26: u64)
112StLoc[4](loc1: u64)
113LdU64(0)
114StLoc[23](loc20: u64)
115MoveLoc[4](loc1: u64)
116StLoc[40](loc37: u64)
B11:
117CopyLoc[23](loc20: u64)
118CopyLoc[40](loc37: u64)
119Lt
120BrFalse(157)
B12:
121CopyLoc[23](loc20: u64)
122StLoc[26](loc23: u64)
123ImmBorrowLoc[37](loc34: vector<u64>)
124CopyLoc[26](loc23: u64)
125VecImmBorrow(13)
126ReadRef
127CopyLoc[28](loc25: u64)
128Neq
129BrFalse(152)
B13:
130ImmBorrowLoc[2](Arg2: vector<u64>)
131CopyLoc[26](loc23: u64)
132VecImmBorrow(13)
133ReadRef
134CastU128
135ImmBorrowLoc[37](loc34: vector<u64>)
136CopyLoc[26](loc23: u64)
137VecImmBorrow(13)
138ReadRef
139CastU128
140LdU128(1)
141Add
142Call uq64_64::from_quotient(u128, u128): UQ64_64
143StLoc[32](loc29: UQ64_64)
144MutBorrowLoc[34](loc31: ApportionmentQueue<u64>)
145MoveLoc[32](loc29: UQ64_64)
146ImmBorrowLoc[0](Arg0: vector<u64>)
147CopyLoc[26](loc23: u64)
148VecImmBorrow(13)
149ReadRef
150MoveLoc[26](loc23: u64)
151Call apportionment_queue::insert<u64>(&mut ApportionmentQueue<u64>, UQ64_64, u64, u64)
B14:
152MoveLoc[23](loc20: u64)
153LdU64(1)
154Add
155StLoc[23](loc20: u64)
156Branch(117)
B15:
157MoveLoc[29](loc26: u64)
158LdU64(0)
159Eq
160BrFalse(163)
B16:
161LdConst[15](vector<u16>: 00)
162Ret
B17:
163CopyLoc[37](loc34: vector<u64>)
164StLoc[48](loc45: vector<u64>)
165LdU64(0)
166StLoc[14](loc11: u64)
167MoveLoc[48](loc45: vector<u64>)
168StLoc[50](loc47: vector<u64>)
169MutBorrowLoc[50](loc47: vector<u64>)
170Call vector::reverse<u64>(&mut vector<u64>)
171ImmBorrowLoc[50](loc47: vector<u64>)
172VecLen(13)
173StLoc[5](loc2: u64)
174LdU64(0)
175StLoc[24](loc21: u64)
176MoveLoc[5](loc2: u64)
177StLoc[41](loc38: u64)
B18:
178CopyLoc[24](loc21: u64)
179CopyLoc[41](loc38: u64)
180Lt
181BrFalse(200)
B19:
182CopyLoc[24](loc21: u64)
183Pop
184MutBorrowLoc[50](loc47: vector<u64>)
185VecPopBack(13)
186StLoc[18](loc15: u64)
187MoveLoc[14](loc11: u64)
188StLoc[15](loc12: u64)
189MoveLoc[18](loc15: u64)
190StLoc[54](loc51: u64)
191MoveLoc[15](loc12: u64)
192MoveLoc[54](loc51: u64)
193Add
194StLoc[14](loc11: u64)
195MoveLoc[24](loc21: u64)
196LdU64(1)
197Add
198StLoc[24](loc21: u64)
199Branch(178)
B20:
200MoveLoc[50](loc47: vector<u64>)
201VecUnpack(13, 0)
202MoveLoc[14](loc11: u64)
203StLoc[31](loc28: u64)
B21:
204CopyLoc[31](loc28: u64)
205CopyLoc[30](loc27: u64)
206Neq
207BrFalse(254)
B22:
208MutBorrowLoc[34](loc31: ApportionmentQueue<u64>)
209Call apportionment_queue::pop_max<u64>(&mut ApportionmentQueue<u64>): UQ64_64 * u64 * u64
210StLoc[27](loc24: u64)
211StLoc[43](loc40: u64)
212Pop
213ImmBorrowLoc[37](loc34: vector<u64>)
214CopyLoc[27](loc24: u64)
215VecImmBorrow(13)
216ReadRef
217LdU64(1)
218Add
219MutBorrowLoc[37](loc34: vector<u64>)
220CopyLoc[27](loc24: u64)
221VecMutBorrow(13)
222WriteRef
223ImmBorrowLoc[37](loc34: vector<u64>)
224CopyLoc[27](loc24: u64)
225VecImmBorrow(13)
226ReadRef
227CopyLoc[28](loc25: u64)
228Neq
229BrFalse(249)
B23:
230ImmBorrowLoc[2](Arg2: vector<u64>)
231CopyLoc[27](loc24: u64)
232VecImmBorrow(13)
233ReadRef
234CastU128
235ImmBorrowLoc[37](loc34: vector<u64>)
236CopyLoc[27](loc24: u64)
237VecImmBorrow(13)
238ReadRef
239CastU128
240LdU128(1)
241Add
242Call uq64_64::from_quotient(u128, u128): UQ64_64
243StLoc[33](loc30: UQ64_64)
244MutBorrowLoc[34](loc31: ApportionmentQueue<u64>)
245MoveLoc[33](loc30: UQ64_64)
246MoveLoc[43](loc40: u64)
247MoveLoc[27](loc24: u64)
248Call apportionment_queue::insert<u64>(&mut ApportionmentQueue<u64>, UQ64_64, u64, u64)
B24:
249MoveLoc[31](loc28: u64)
250LdU64(1)
251Add
252StLoc[31](loc28: u64)
253Branch(204)
B25:
254MoveLoc[37](loc34: vector<u64>)
255StLoc[51](loc48: vector<u64>)
256LdConst[15](vector<u16>: 00)
257StLoc[36](loc33: vector<u16>)
258MoveLoc[51](loc48: vector<u64>)
259StLoc[52](loc49: vector<u64>)
260MutBorrowLoc[52](loc49: vector<u64>)
261Call vector::reverse<u64>(&mut vector<u64>)
262ImmBorrowLoc[52](loc49: vector<u64>)
263VecLen(13)
264StLoc[6](loc3: u64)
265LdU64(0)
266StLoc[25](loc22: u64)
267MoveLoc[6](loc3: u64)
268StLoc[42](loc39: u64)
B26:
269CopyLoc[25](loc22: u64)
270CopyLoc[42](loc39: u64)
271Lt
272BrFalse(291)
B27:
273CopyLoc[25](loc22: u64)
274Pop
275MutBorrowLoc[52](loc49: vector<u64>)
276VecPopBack(13)
277StLoc[19](loc16: u64)
278MutBorrowLoc[36](loc33: vector<u16>)
279StLoc[8](loc5: &mut vector<u16>)
280MoveLoc[19](loc16: u64)
281CastU16
282StLoc[11](loc8: u16)
283MoveLoc[8](loc5: &mut vector<u16>)
284MoveLoc[11](loc8: u16)
285VecPushBack(16)
286MoveLoc[25](loc22: u64)
287LdU64(1)
288Add
289StLoc[25](loc22: u64)
290Branch(269)
B28:
291MoveLoc[52](loc49: vector<u64>)
292VecUnpack(13, 0)
293MoveLoc[36](loc33: vector<u16>)
294Ret
}
max_shards_per_node(Arg0: u64, Arg1: u64): u64 {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: u64)
1LdConst[2](u8: 20)
2CastU64
3Ge
4BrFalse(11)
B1:
5MoveLoc[1](Arg1: u64)
6LdConst[3](u8: 10)
7CastU64
8Div
9StLoc[2](loc0: u64)
10Branch(21)
B2:
11MoveLoc[1](Arg1: u64)
12LdConst[2](u8: 20)
13CastU64
14Mul
15MoveLoc[0](Arg0: u64)
16LdConst[3](u8: 10)
17CastU64
18Mul
19Call u64::div_ceil(u64, u64): u64
20StLoc[2](loc0: u64)
B3:
21MoveLoc[2](loc0: u64)
22Ret
}
public(friend) initiate_epoch_change(Arg0: &mut StakingInnerV1, Arg1: &Clock, Arg2: VecMap<ID, Balance<WAL>>) {
L3: loc0: &EpochState
L4: loc1: EpochState
L5: loc2: u64
L6: loc3: u64
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
2ReadRef
3StLoc[4](loc1: EpochState)
4ImmBorrowLoc[4](loc1: EpochState)
5StLoc[3](loc0: &EpochState)
6CopyLoc[3](loc0: &EpochState)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[0](Arg0: &mut StakingInnerV1)
9Pop
10MoveLoc[1](Arg1: &Clock)
11Pop
12MoveLoc[3](loc0: &EpochState)
13Pop
14LdConst[0](u64: 0)
15Abort
B2:
16MoveLoc[0](Arg0: &mut StakingInnerV1)
17Pop
18MoveLoc[1](Arg1: &Clock)
19Pop
20MoveLoc[3](loc0: &EpochState)
21Pop
22LdConst[0](u64: 0)
23Abort
B3:
24MoveLoc[3](loc0: &EpochState)
25UnpackVariantImmRef(VariantHandleIndex(0))
26Pop
27MoveLoc[4](loc1: EpochState)
28UnpackVariant(VariantHandleIndex(0))
29StLoc[5](loc2: u64)
30MoveLoc[1](Arg1: &Clock)
31Call clock::timestamp_ms(&Clock): u64
32StLoc[6](loc3: u64)
33CopyLoc[0](Arg0: &mut StakingInnerV1)
34ImmBorrowField[3](StakingInnerV1.epoch: u32)
35ReadRef
36LdU32(0)
37Eq
38BrFalse(50)
B4:
39MoveLoc[6](loc3: u64)
40CopyLoc[0](Arg0: &mut StakingInnerV1)
41ImmBorrowField[4](StakingInnerV1.first_epoch_start: u64)
42ReadRef
43Ge
44BrFalse(46)
B5:
45Branch(63)
B6:
46MoveLoc[0](Arg0: &mut StakingInnerV1)
47Pop
48LdConst[0](u64: 0)
49Abort
B7:
50MoveLoc[6](loc3: u64)
51MoveLoc[5](loc2: u64)
52CopyLoc[0](Arg0: &mut StakingInnerV1)
53ImmBorrowField[2](StakingInnerV1.epoch_duration: u64)
54ReadRef
55Add
56Ge
57BrFalse(59)
B8:
58Branch(63)
B9:
59MoveLoc[0](Arg0: &mut StakingInnerV1)
60Pop
61LdConst[0](u64: 0)
62Abort
B10:
63MoveLoc[0](Arg0: &mut StakingInnerV1)
64MoveLoc[2](Arg2: VecMap<ID, Balance<WAL>>)
65Call advance_epoch(&mut StakingInnerV1, VecMap<ID, Balance<WAL>>)
66Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 8
Variant1 => jump 16
Variant2 => jump 24
}
}
public(friend) advance_epoch(Arg0: &mut StakingInnerV1, Arg1: VecMap<ID, Balance<WAL>>) {
L2: loc0: u64
L3: loc1: u64
L4: loc2: WalrusContext
L5: loc3: &mut ActiveSet
L6: loc4: u64
L7: loc5: u64
L8: loc6: vector<ID>
L9: loc7: ID
L10: loc8: ID
L11: loc9: vector<ID>
L12: loc10: Balance<WAL>
L13: loc11: &mut StakingPool
L14: loc12: &mut StakingPool
L15: loc13: vector<Balance<WAL>>
L16: loc14: u64
L17: loc15: u64
L18: loc16: vector<ID>
L19: loc17: vector<Balance<WAL>>
L20: loc18: vector<Balance<WAL>>
L21: loc19: vector<ID>
L22: loc20: &WalrusContext
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
2Call option::is_some<Committee>(&Option<Committee>): bool
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut StakingInnerV1)
6Pop
7LdConst[0](u64: 0)
8Abort
B3:
9CopyLoc[0](Arg0: &mut StakingInnerV1)
10ImmBorrowField[3](StakingInnerV1.epoch: u32)
11ReadRef
12LdU32(1)
13Add
14CopyLoc[0](Arg0: &mut StakingInnerV1)
15MutBorrowField[3](StakingInnerV1.epoch: u32)
16WriteRef
17CopyLoc[0](Arg0: &mut StakingInnerV1)
18ImmBorrowField[10](StakingInnerV1.committee: Committee)
19ReadRef
20CopyLoc[0](Arg0: &mut StakingInnerV1)
21MutBorrowField[5](StakingInnerV1.previous_committee: Committee)
22WriteRef
23CopyLoc[0](Arg0: &mut StakingInnerV1)
24MutBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
25Call option::extract<Committee>(&mut Option<Committee>): Committee
26CopyLoc[0](Arg0: &mut StakingInnerV1)
27MutBorrowField[10](StakingInnerV1.committee: Committee)
28WriteRef
29LdU16(0)
30PackVariant(VariantHandleIndex(2))
31CopyLoc[0](Arg0: &mut StakingInnerV1)
32MutBorrowField[1](StakingInnerV1.epoch_state: EpochState)
33WriteRef
34CopyLoc[0](Arg0: &mut StakingInnerV1)
35FreezeRef
36Call new_walrus_context(&StakingInnerV1): WalrusContext
37StLoc[4](loc2: WalrusContext)
38ImmBorrowLoc[4](loc2: WalrusContext)
39StLoc[22](loc20: &WalrusContext)
40CopyLoc[0](Arg0: &mut StakingInnerV1)
41MutBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
42Call extended_field::borrow_mut<ActiveSet>(&mut ExtendedField<ActiveSet>): &mut ActiveSet
43StLoc[5](loc3: &mut ActiveSet)
44CopyLoc[0](Arg0: &mut StakingInnerV1)
45ImmBorrowField[5](StakingInnerV1.previous_committee: Committee)
46CopyLoc[0](Arg0: &mut StakingInnerV1)
47ImmBorrowField[10](StakingInnerV1.committee: Committee)
48Call committee::diff(&Committee, &Committee): vector<ID> * vector<ID>
49StLoc[8](loc6: vector<ID>)
50Pop
51MoveLoc[1](Arg1: VecMap<ID, Balance<WAL>>)
52Call vec_map::into_keys_values<ID, Balance<WAL>>(VecMap<ID, Balance<WAL>>): vector<ID> * vector<Balance<WAL>>
53StLoc[15](loc13: vector<Balance<WAL>>)
54StLoc[11](loc9: vector<ID>)
55MoveLoc[15](loc13: vector<Balance<WAL>>)
56StLoc[20](loc18: vector<Balance<WAL>>)
57MoveLoc[11](loc9: vector<ID>)
58StLoc[21](loc19: vector<ID>)
59MutBorrowLoc[21](loc19: vector<ID>)
60Call vector::reverse<ID>(&mut vector<ID>)
61ImmBorrowLoc[20](loc18: vector<Balance<WAL>>)
62VecLen(9)
63ImmBorrowLoc[21](loc19: vector<ID>)
64VecLen(5)
65Eq
66BrFalse(68)
B4:
67Branch(76)
B5:
68MoveLoc[22](loc20: &WalrusContext)
69Pop
70MoveLoc[0](Arg0: &mut StakingInnerV1)
71Pop
72MoveLoc[5](loc3: &mut ActiveSet)
73Pop
74LdU64(13906837249539964927)
75Abort
B6:
76MoveLoc[20](loc18: vector<Balance<WAL>>)
77StLoc[19](loc17: vector<Balance<WAL>>)
78MutBorrowLoc[19](loc17: vector<Balance<WAL>>)
79Call vector::reverse<Balance<WAL>>(&mut vector<Balance<WAL>>)
80ImmBorrowLoc[19](loc17: vector<Balance<WAL>>)
81VecLen(9)
82StLoc[3](loc1: u64)
83LdU64(0)
84StLoc[6](loc4: u64)
85MoveLoc[3](loc1: u64)
86StLoc[16](loc14: u64)
B7:
87CopyLoc[6](loc4: u64)
88CopyLoc[16](loc14: u64)
89Lt
90BrFalse(124)
B8:
91CopyLoc[6](loc4: u64)
92Pop
93MutBorrowLoc[19](loc17: vector<Balance<WAL>>)
94VecPopBack(9)
95StLoc[12](loc10: Balance<WAL>)
96MutBorrowLoc[21](loc19: vector<ID>)
97VecPopBack(5)
98StLoc[9](loc7: ID)
99CopyLoc[0](Arg0: &mut StakingInnerV1)
100MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
101CopyLoc[9](loc7: ID)
102Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
103StLoc[13](loc11: &mut StakingPool)
104CopyLoc[13](loc11: &mut StakingPool)
105MoveLoc[12](loc10: Balance<WAL>)
106CopyLoc[22](loc20: &WalrusContext)
107Call staking_pool::advance_epoch(&mut StakingPool, Balance<WAL>, &WalrusContext)
108CopyLoc[5](loc3: &mut ActiveSet)
109MoveLoc[9](loc7: ID)
110MoveLoc[13](loc11: &mut StakingPool)
111FreezeRef
112CopyLoc[22](loc20: &WalrusContext)
113Call walrus_context::epoch(&WalrusContext): u32
114LdU32(1)
115Add
116Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
117Call active_set::insert_or_update(&mut ActiveSet, ID, u64): bool
118Pop
119MoveLoc[6](loc4: u64)
120LdU64(1)
121Add
122StLoc[6](loc4: u64)
123Branch(87)
B9:
124MoveLoc[19](loc17: vector<Balance<WAL>>)
125VecUnpack(9, 0)
126MoveLoc[21](loc19: vector<ID>)
127VecUnpack(5, 0)
128MoveLoc[8](loc6: vector<ID>)
129StLoc[18](loc16: vector<ID>)
130MutBorrowLoc[18](loc16: vector<ID>)
131Call vector::reverse<ID>(&mut vector<ID>)
132ImmBorrowLoc[18](loc16: vector<ID>)
133VecLen(5)
134StLoc[2](loc0: u64)
135LdU64(0)
136StLoc[7](loc5: u64)
137MoveLoc[2](loc0: u64)
138StLoc[17](loc15: u64)
B10:
139CopyLoc[7](loc5: u64)
140CopyLoc[17](loc15: u64)
141Lt
142BrFalse(173)
B11:
143CopyLoc[7](loc5: u64)
144Pop
145MutBorrowLoc[18](loc16: vector<ID>)
146VecPopBack(5)
147StLoc[10](loc8: ID)
148CopyLoc[0](Arg0: &mut StakingInnerV1)
149MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
150CopyLoc[10](loc8: ID)
151Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
152StLoc[14](loc12: &mut StakingPool)
153CopyLoc[14](loc12: &mut StakingPool)
154Call balance::zero<WAL>(): Balance<WAL>
155CopyLoc[22](loc20: &WalrusContext)
156Call staking_pool::advance_epoch(&mut StakingPool, Balance<WAL>, &WalrusContext)
157CopyLoc[5](loc3: &mut ActiveSet)
158MoveLoc[10](loc8: ID)
159MoveLoc[14](loc12: &mut StakingPool)
160FreezeRef
161CopyLoc[22](loc20: &WalrusContext)
162Call walrus_context::epoch(&WalrusContext): u32
163LdU32(1)
164Add
165Call staking_pool::wal_balance_at_epoch(&StakingPool, u32): u64
166Call active_set::insert_or_update(&mut ActiveSet, ID, u64): bool
167Pop
168MoveLoc[7](loc5: u64)
169LdU64(1)
170Add
171StLoc[7](loc5: u64)
172Branch(139)
B12:
173MoveLoc[22](loc20: &WalrusContext)
174Pop
175MoveLoc[5](loc3: &mut ActiveSet)
176Pop
177MoveLoc[18](loc16: vector<ID>)
178VecUnpack(5, 0)
179MoveLoc[0](Arg0: &mut StakingInnerV1)
180ImmBorrowField[3](StakingInnerV1.epoch: u32)
181ReadRef
182Call events::emit_epoch_change_start(u32)
183Ret
}
public(friend) epoch_sync_done(Arg0: &mut StakingInnerV1, Arg1: &mut StorageNodeCap, Arg2: u32, Arg3: &Clock) {
L4: loc0: ID
L5: loc1: &VecMap<ID, vector<u16>>
L6: loc2: ID
L7: loc3: &Committee
L8: loc4: &EpochState
L9: loc5: EpochState
L10: loc6: &vector<u16>
L11: loc7: u16
B0:
0MoveLoc[2](Arg2: u32)
1CopyLoc[0](Arg0: &mut StakingInnerV1)
2ImmBorrowField[3](StakingInnerV1.epoch: u32)
3ReadRef
4Eq
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &mut StakingInnerV1)
8Pop
9MoveLoc[3](Arg3: &Clock)
10Pop
11MoveLoc[1](Arg1: &mut StorageNodeCap)
12Pop
13LdConst[4](u64: 1)
14Abort
B3:
15CopyLoc[1](Arg1: &mut StorageNodeCap)
16FreezeRef
17Call storage_node::last_epoch_sync_done(&StorageNodeCap): u32
18CopyLoc[0](Arg0: &mut StakingInnerV1)
19ImmBorrowField[3](StakingInnerV1.epoch: u32)
20ReadRef
21Lt
22BrFalse(24)
B4:
23Branch(32)
B5:
24MoveLoc[0](Arg0: &mut StakingInnerV1)
25Pop
26MoveLoc[3](Arg3: &Clock)
27Pop
28MoveLoc[1](Arg1: &mut StorageNodeCap)
29Pop
30LdConst[5](u64: 2)
31Abort
B6:
32CopyLoc[1](Arg1: &mut StorageNodeCap)
33CopyLoc[0](Arg0: &mut StakingInnerV1)
34ImmBorrowField[3](StakingInnerV1.epoch: u32)
35ReadRef
36Call storage_node::set_last_epoch_sync_done(&mut StorageNodeCap, u32)
37CopyLoc[0](Arg0: &mut StakingInnerV1)
38ImmBorrowField[10](StakingInnerV1.committee: Committee)
39Call committee::inner(&Committee): &VecMap<ID, vector<u16>>
40StLoc[5](loc1: &VecMap<ID, vector<u16>>)
41CopyLoc[1](Arg1: &mut StorageNodeCap)
42FreezeRef
43Call storage_node::node_id(&StorageNodeCap): ID
44StLoc[4](loc0: ID)
45MoveLoc[5](loc1: &VecMap<ID, vector<u16>>)
46ImmBorrowLoc[4](loc0: ID)
47Call vec_map::contains<ID, vector<u16>>(&VecMap<ID, vector<u16>>, &ID): bool
48BrFalse(50)
B7:
49Branch(58)
B8:
50MoveLoc[0](Arg0: &mut StakingInnerV1)
51Pop
52MoveLoc[3](Arg3: &Clock)
53Pop
54MoveLoc[1](Arg1: &mut StorageNodeCap)
55Pop
56LdConst[7](u64: 4)
57Abort
B9:
58CopyLoc[0](Arg0: &mut StakingInnerV1)
59ImmBorrowField[10](StakingInnerV1.committee: Committee)
60StLoc[7](loc3: &Committee)
61MoveLoc[1](Arg1: &mut StorageNodeCap)
62FreezeRef
63Call storage_node::node_id(&StorageNodeCap): ID
64StLoc[6](loc2: ID)
65MoveLoc[7](loc3: &Committee)
66ImmBorrowLoc[6](loc2: ID)
67Call committee::shards(&Committee, &ID): &vector<u16>
68StLoc[10](loc6: &vector<u16>)
69CopyLoc[0](Arg0: &mut StakingInnerV1)
70ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
71ReadRef
72StLoc[9](loc5: EpochState)
73ImmBorrowLoc[9](loc5: EpochState)
74StLoc[8](loc4: &EpochState)
75CopyLoc[8](loc4: &EpochState)
76VariantSwitch(VariantJumpTableIndex(0))
B10:
77MoveLoc[8](loc4: &EpochState)
78UnpackVariantImmRef(VariantHandleIndex(2))
79Pop
80MoveLoc[9](loc5: EpochState)
81UnpackVariant(VariantHandleIndex(2))
82CopyLoc[10](loc6: &vector<u16>)
83VecLen(16)
84CastU16
85Add
86StLoc[11](loc7: u16)
87CopyLoc[0](Arg0: &mut StakingInnerV1)
88FreezeRef
89CopyLoc[11](loc7: u16)
90Call is_quorum(&StakingInnerV1, u16): bool
91BrFalse(103)
B11:
92MoveLoc[3](Arg3: &Clock)
93Call clock::timestamp_ms(&Clock): u64
94PackVariant(VariantHandleIndex(1))
95CopyLoc[0](Arg0: &mut StakingInnerV1)
96MutBorrowField[1](StakingInnerV1.epoch_state: EpochState)
97WriteRef
98CopyLoc[0](Arg0: &mut StakingInnerV1)
99ImmBorrowField[3](StakingInnerV1.epoch: u32)
100ReadRef
101Call events::emit_epoch_change_done(u32)
102Branch(120)
B12:
103MoveLoc[3](Arg3: &Clock)
104Pop
105MoveLoc[11](loc7: u16)
106PackVariant(VariantHandleIndex(2))
107CopyLoc[0](Arg0: &mut StakingInnerV1)
108MutBorrowField[1](StakingInnerV1.epoch_state: EpochState)
109WriteRef
110Branch(120)
B13:
111MoveLoc[3](Arg3: &Clock)
112Pop
113MoveLoc[8](loc4: &EpochState)
114Pop
115Branch(120)
B14:
116MoveLoc[3](Arg3: &Clock)
117Pop
118MoveLoc[8](loc4: &EpochState)
119Pop
B15:
120MoveLoc[0](Arg0: &mut StakingInnerV1)
121ImmBorrowField[3](StakingInnerV1.epoch: u32)
122ReadRef
123MoveLoc[10](loc6: &vector<u16>)
124ReadRef
125Call events::emit_shards_received(u32, vector<u16>)
126Ret
Jump tables:
[0]: variant_switch EpochState {
Variant0 => jump 77
Variant1 => jump 111
Variant2 => jump 116
}
}
public(friend) extract_commission_to_burn(Arg0: &mut StakingInnerV1, Arg1: ID): Balance<WAL> {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
4Call staking_pool::extract_commission_to_burn(&mut StakingPool): Balance<WAL>
5Ret
}
public(friend) add_commission_to_pools(Arg0: &mut StakingInnerV1, Arg1: vector<ID>, Arg2: vector<Balance<WAL>>) {
L3: loc0: u64
L4: loc1: bool
L5: loc2: Balance<WAL>
L6: loc3: u64
L7: loc4: ID
L8: loc5: u64
L9: loc6: vector<ID>
L10: loc7: vector<ID>
L11: loc8: vector<Balance<WAL>>
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[1](StakingInnerV1.epoch_state: EpochState)
2Call is_next_params_selected(&EpochState): bool
3Not
4StLoc[4](loc1: bool)
5MoveLoc[1](Arg1: vector<ID>)
6StLoc[10](loc7: vector<ID>)
7MoveLoc[2](Arg2: vector<Balance<WAL>>)
8StLoc[11](loc8: vector<Balance<WAL>>)
9MutBorrowLoc[11](loc8: vector<Balance<WAL>>)
10Call vector::reverse<Balance<WAL>>(&mut vector<Balance<WAL>>)
11ImmBorrowLoc[10](loc7: vector<ID>)
12VecLen(5)
13ImmBorrowLoc[11](loc8: vector<Balance<WAL>>)
14VecLen(9)
15Eq
16BrFalse(18)
B1:
17Branch(22)
B2:
18MoveLoc[0](Arg0: &mut StakingInnerV1)
19Pop
20LdU64(13906837541597741055)
21Abort
B3:
22MoveLoc[10](loc7: vector<ID>)
23StLoc[9](loc6: vector<ID>)
24MutBorrowLoc[9](loc6: vector<ID>)
25Call vector::reverse<ID>(&mut vector<ID>)
26ImmBorrowLoc[9](loc6: vector<ID>)
27VecLen(5)
28StLoc[3](loc0: u64)
29LdU64(0)
30StLoc[6](loc3: u64)
31MoveLoc[3](loc0: u64)
32StLoc[8](loc5: u64)
B4:
33CopyLoc[6](loc3: u64)
34CopyLoc[8](loc5: u64)
35Lt
36BrFalse(58)
B5:
37CopyLoc[6](loc3: u64)
38Pop
39MutBorrowLoc[9](loc6: vector<ID>)
40VecPopBack(5)
41StLoc[7](loc4: ID)
42MutBorrowLoc[11](loc8: vector<Balance<WAL>>)
43VecPopBack(9)
44StLoc[5](loc2: Balance<WAL>)
45CopyLoc[0](Arg0: &mut StakingInnerV1)
46MutBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
47MoveLoc[7](loc4: ID)
48Call object_table::borrow_mut<ID, StakingPool>(&mut ObjectTable<ID, StakingPool>, ID): &mut StakingPool
49MoveLoc[5](loc2: Balance<WAL>)
50CopyLoc[4](loc1: bool)
51Call staking_pool::add_commission(&mut StakingPool, Balance<WAL>, bool): u64
52Pop
53MoveLoc[6](loc3: u64)
54LdU64(1)
55Add
56StLoc[6](loc3: u64)
57Branch(33)
B6:
58MoveLoc[0](Arg0: &mut StakingInnerV1)
59Pop
60MoveLoc[9](loc6: vector<ID>)
61VecUnpack(5, 0)
62MoveLoc[11](loc8: vector<Balance<WAL>>)
63VecUnpack(9, 0)
64Ret
}
public(friend) node_metadata(Arg0: &StakingInnerV1, Arg1: ID): NodeMetadata {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::borrow<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): &StakingPool
4Call staking_pool::node_info(&StakingPool): &StorageNodeInfo
5Call storage_node::metadata(&StorageNodeInfo): NodeMetadata
6Ret
}
public(friend) next_committee(Arg0: &StakingInnerV1): &Option<Committee> {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
2Ret
}
public(friend) next_epoch_params(Arg0: &StakingInnerV1): &EpochParams {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[9](StakingInnerV1.next_epoch_params: Option<EpochParams>)
2Call option::borrow<EpochParams>(&Option<EpochParams>): &EpochParams
3Ret
}
public(friend) epoch(Arg0: &StakingInnerV1): u32 {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[3](StakingInnerV1.epoch: u32)
2ReadRef
3Ret
}
public(friend) committee(Arg0: &StakingInnerV1): &Committee {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[10](StakingInnerV1.committee: Committee)
2Ret
}
public(friend) previous_committee(Arg0: &StakingInnerV1): &Committee {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[5](StakingInnerV1.previous_committee: Committee)
2Ret
}
public(friend) next_bls_committee(Arg0: &mut StakingInnerV1): BlsCommittee {
L1: loc0: u64
L2: loc1: BlsCommitteeMember
L3: loc2: &mut vector<BlsCommitteeMember>
L4: loc3: u64
L5: loc4: u64
L6: loc5: u64
L7: loc6: vector<ID>
L8: loc7: vector<BlsCommitteeMember>
L9: loc8: &ID
L10: loc9: Element<UncompressedG1>
L11: loc10: vector<ID>
L12: loc11: &ID
L13: loc12: vector<Element<UncompressedG1>>
L14: loc13: vector<vector<u16>>
L15: loc14: u16
L16: loc15: u64
L17: loc16: vector<BlsCommitteeMember>
B0:
0CopyLoc[0](Arg0: &mut StakingInnerV1)
1ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
2Call option::is_some<Committee>(&Option<Committee>): bool
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut StakingInnerV1)
6Pop
7LdConst[9](u64: 6)
8Abort
B3:
9CopyLoc[0](Arg0: &mut StakingInnerV1)
10MutBorrowField[8](StakingInnerV1.next_epoch_public_keys: ExtendedField<VecMap<ID, Element<UncompressedG1>>>)
11Call vec_map::empty<ID, Element<UncompressedG1>>(): VecMap<ID, Element<UncompressedG1>>
12Call extended_field::swap<VecMap<ID, Element<UncompressedG1>>>(&mut ExtendedField<VecMap<ID, Element<UncompressedG1>>>, VecMap<ID, Element<UncompressedG1>>): VecMap<ID, Element<UncompressedG1>>
13Call vec_map::into_keys_values<ID, Element<UncompressedG1>>(VecMap<ID, Element<UncompressedG1>>): vector<ID> * vector<Element<UncompressedG1>>
14StLoc[13](loc12: vector<Element<UncompressedG1>>)
15StLoc[11](loc10: vector<ID>)
16CopyLoc[0](Arg0: &mut StakingInnerV1)
17ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
18Call option::borrow<Committee>(&Option<Committee>): &Committee
19Call committee::inner(&Committee): &VecMap<ID, vector<u16>>
20ReadRef
21Call vec_map::into_keys_values<ID, vector<u16>>(VecMap<ID, vector<u16>>): vector<ID> * vector<vector<u16>>
22StLoc[14](loc13: vector<vector<u16>>)
23StLoc[7](loc6: vector<ID>)
24VecPack(162, 0)
25StLoc[17](loc16: vector<BlsCommitteeMember>)
26ImmBorrowLoc[7](loc6: vector<ID>)
27VecLen(5)
28StLoc[1](loc0: u64)
29LdU64(0)
30StLoc[6](loc5: u64)
31MoveLoc[1](loc0: u64)
32StLoc[16](loc15: u64)
B4:
33CopyLoc[6](loc5: u64)
34CopyLoc[16](loc15: u64)
35Lt
36BrFalse(89)
B5:
37CopyLoc[6](loc5: u64)
38StLoc[4](loc3: u64)
39MutBorrowLoc[17](loc16: vector<BlsCommitteeMember>)
40StLoc[3](loc2: &mut vector<BlsCommitteeMember>)
41MoveLoc[4](loc3: u64)
42StLoc[5](loc4: u64)
43ImmBorrowLoc[7](loc6: vector<ID>)
44CopyLoc[5](loc4: u64)
45VecImmBorrow(5)
46StLoc[9](loc8: &ID)
47ImmBorrowLoc[14](loc13: vector<vector<u16>>)
48CopyLoc[5](loc4: u64)
49VecImmBorrow(35)
50VecLen(16)
51CastU16
52StLoc[15](loc14: u16)
53ImmBorrowLoc[11](loc10: vector<ID>)
54CopyLoc[5](loc4: u64)
55VecImmBorrow(5)
56StLoc[12](loc11: &ID)
57ImmBorrowLoc[13](loc12: vector<Element<UncompressedG1>>)
58MoveLoc[5](loc4: u64)
59VecImmBorrow(84)
60ReadRef
61StLoc[10](loc9: Element<UncompressedG1>)
62CopyLoc[9](loc8: &ID)
63MoveLoc[12](loc11: &ID)
64Eq
65BrFalse(67)
B6:
66Branch(75)
B7:
67MoveLoc[0](Arg0: &mut StakingInnerV1)
68Pop
69MoveLoc[9](loc8: &ID)
70Pop
71MoveLoc[3](loc2: &mut vector<BlsCommitteeMember>)
72Pop
73LdConst[13](u64: 10)
74Abort
B8:
75MoveLoc[10](loc9: Element<UncompressedG1>)
76MoveLoc[15](loc14: u16)
77MoveLoc[9](loc8: &ID)
78ReadRef
79Call bls_aggregate::new_bls_committee_member(Element<UncompressedG1>, u16, ID): BlsCommitteeMember
80StLoc[2](loc1: BlsCommitteeMember)
81MoveLoc[3](loc2: &mut vector<BlsCommitteeMember>)
82MoveLoc[2](loc1: BlsCommitteeMember)
83VecPushBack(162)
84MoveLoc[6](loc5: u64)
85LdU64(1)
86Add
87StLoc[6](loc5: u64)
88Branch(33)
B9:
89MoveLoc[17](loc16: vector<BlsCommitteeMember>)
90StLoc[8](loc7: vector<BlsCommitteeMember>)
91MoveLoc[0](Arg0: &mut StakingInnerV1)
92ImmBorrowField[3](StakingInnerV1.epoch: u32)
93ReadRef
94LdU32(1)
95Add
96MoveLoc[8](loc7: vector<BlsCommitteeMember>)
97Call bls_aggregate::new_bls_committee(u32, vector<BlsCommitteeMember>): BlsCommittee
98Ret
}
public(friend) has_pool(Arg0: &StakingInnerV1, Arg1: ID): bool {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2MoveLoc[1](Arg1: ID)
3Call object_table::contains<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): bool
4Ret
}
public(friend) n_shards(Arg0: &StakingInnerV1): u16 {
B0:
0MoveLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[7](StakingInnerV1.n_shards: u16)
2ReadRef
3Ret
}
public(friend) calculate_rewards(Arg0: &StakingInnerV1, Arg1: ID, Arg2: u64, Arg3: u32, Arg4: u32): u64 {
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
2CopyLoc[1](Arg1: ID)
3Call object_table::contains<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &StakingInnerV1)
7Pop
8LdConst[11](u64: 8)
9Abort
B3:
10MoveLoc[0](Arg0: &StakingInnerV1)
11ImmBorrowField[0](StakingInnerV1.pools: ObjectTable<ID, StakingPool>)
12MoveLoc[1](Arg1: ID)
13Call object_table::borrow<ID, StakingPool>(&ObjectTable<ID, StakingPool>, ID): &StakingPool
14MoveLoc[2](Arg2: u64)
15MoveLoc[3](Arg3: u32)
16MoveLoc[4](Arg4: u32)
17Call staking_pool::calculate_rewards(&StakingPool, u64, u32, u32): u64
18Ret
}
public(friend) can_withdraw_staked_wal_early(Arg0: &StakingInnerV1, Arg1: &StakedWal): bool {
L2: loc0: bool
L3: loc1: ID
L4: loc2: &Committee
L5: loc3: WalrusContext
L6: loc4: bool
L7: loc5: &StakedWal
L8: loc6: bool
L9: loc7: &Option<Committee>
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
2StLoc[9](loc7: &Option<Committee>)
3CopyLoc[9](loc7: &Option<Committee>)
4Call option::is_some<Committee>(&Option<Committee>): bool
5BrFalse(17)
B1:
6MoveLoc[9](loc7: &Option<Committee>)
7Call option::borrow<Committee>(&Option<Committee>): &Committee
8StLoc[4](loc2: &Committee)
9CopyLoc[1](Arg1: &StakedWal)
10Call staked_wal::node_id(&StakedWal): ID
11StLoc[3](loc1: ID)
12MoveLoc[4](loc2: &Committee)
13ImmBorrowLoc[3](loc1: ID)
14Call committee::contains(&Committee, &ID): bool
15StLoc[2](loc0: bool)
16Branch(21)
B2:
17MoveLoc[9](loc7: &Option<Committee>)
18Pop
19LdFalse
20StLoc[2](loc0: bool)
B3:
21MoveLoc[2](loc0: bool)
22StLoc[8](loc6: bool)
23MoveLoc[1](Arg1: &StakedWal)
24StLoc[7](loc5: &StakedWal)
25MoveLoc[8](loc6: bool)
26StLoc[6](loc4: bool)
27MoveLoc[0](Arg0: &StakingInnerV1)
28Call new_walrus_context(&StakingInnerV1): WalrusContext
29StLoc[5](loc3: WalrusContext)
30MoveLoc[7](loc5: &StakedWal)
31MoveLoc[6](loc4: bool)
32ImmBorrowLoc[5](loc3: WalrusContext)
33Call staked_wal::can_withdraw_early(&StakedWal, bool, &WalrusContext): bool
34Ret
}
new_walrus_context(Arg0: &StakingInnerV1): WalrusContext {
B0:
0CopyLoc[0](Arg0: &StakingInnerV1)
1ImmBorrowField[3](StakingInnerV1.epoch: u32)
2ReadRef
3CopyLoc[0](Arg0: &StakingInnerV1)
4ImmBorrowField[6](StakingInnerV1.next_committee: Option<Committee>)
5Call option::is_some<Committee>(&Option<Committee>): bool
6MoveLoc[0](Arg0: &StakingInnerV1)
7ImmBorrowField[10](StakingInnerV1.committee: Committee)
8Call committee::to_inner(&Committee): VecMap<ID, vector<u16>>
9Call walrus_context::new(u32, bool, VecMap<ID, vector<u16>>): WalrusContext
10Ret
}
public(friend) is_quorum(Arg0: &StakingInnerV1, Arg1: u16): bool {
B0:
0MoveLoc[1](Arg1: u16)
1CastU64
2MoveLoc[0](Arg0: &StakingInnerV1)
3ImmBorrowField[7](StakingInnerV1.n_shards: u16)
4ReadRef
5CastU64
6Call is_quorum_for_n_shards(u64, u64): bool
7Ret
}
is_quorum_for_n_shards(Arg0: u64, Arg1: u64): bool {
B0:
0LdU64(3)
1MoveLoc[0](Arg0: u64)
2Mul
3LdU64(2)
4MoveLoc[1](Arg1: u64)
5Mul
6LdU64(1)
7Add
8Ge
9Ret
}
public(friend) update_active_set_max_size(Arg0: &mut StakingInnerV1) {
B0:
0MoveLoc[0](Arg0: &mut StakingInnerV1)
1MutBorrowField[11](StakingInnerV1.active_set: ExtendedField<ActiveSet>)
2Call extended_field::borrow_mut<ActiveSet>(&mut ExtendedField<ActiveSet>): &mut ActiveSet
3LdConst[1](u16: 150)
4Call active_set::set_max_size(&mut ActiveSet, u16)
5Ret
}
Constants [
0 => u64: 0
1 => u16: 150
2 => u8: 20
3 => u8: 10
4 => u64: 1
5 => u64: 2
6 => u64: 3
7 => u64: 4
8 => u64: 5
9 => u64: 6
10 => u64: 7
11 => u64: 8
12 => u64: 9
13 => u64: 10
14 => vector<u64>: 00
15 => vector<u16>: 00
]
}