staking
Module0xfa65…814e
- Move path
- 0xfdc8…ea77::staking
- Functions
- 3927 public, 1 entry
- Structs
- 1
staking
- 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
Bytecode670 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.staking {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::auth;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::bls_aggregate;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::committee;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::epoch_parameters;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::node_metadata;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::staked_wal;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::staking_inner;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_node;
use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::system;
struct Staking has key {
id: UID,
version: u64,
package_id: ID,
new_package_id: Option<ID>
}
public(friend) create(Arg0: u64, Arg1: u64, Arg2: u16, Arg3: ID, Arg4: &Clock, Arg5: &mut TxContext) {
L6: loc0: Staking
B0:
0CopyLoc[5](Arg5: &mut TxContext)
1Call object::new(&mut TxContext): UID
2LdConst[3](u64: 4)
3MoveLoc[3](Arg3: ID)
4Call option::none<ID>(): Option<ID>
5Pack[0](Staking)
6StLoc[6](loc0: Staking)
7MutBorrowLoc[6](loc0: Staking)
8MutBorrowField[0](Staking.id: UID)
9LdConst[3](u64: 4)
10MoveLoc[0](Arg0: u64)
11MoveLoc[1](Arg1: u64)
12MoveLoc[2](Arg2: u16)
13MoveLoc[4](Arg4: &Clock)
14MoveLoc[5](Arg5: &mut TxContext)
15Call staking_inner::new(u64, u64, u16, &Clock, &mut TxContext): StakingInnerV1
16Call dynamic_field::add<u64, StakingInnerV1>(&mut UID, u64, StakingInnerV1)
17MoveLoc[6](loc0: Staking)
18Call transfer::share_object<Staking>(Staking)
19Ret
}
public register_candidate(Arg0: &mut Staking, 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): StorageNodeCap {
L12: loc0: StorageNodeCap
L13: loc1: ID
L14: loc2: Authorized
L15: loc3: &mut StakingInnerV1
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2StLoc[15](loc3: &mut StakingInnerV1)
3CopyLoc[15](loc3: &mut StakingInnerV1)
4MoveLoc[1](Arg1: String)
5MoveLoc[2](Arg2: String)
6MoveLoc[3](Arg3: NodeMetadata)
7MoveLoc[4](Arg4: vector<u8>)
8MoveLoc[5](Arg5: vector<u8>)
9MoveLoc[6](Arg6: vector<u8>)
10MoveLoc[7](Arg7: u16)
11MoveLoc[8](Arg8: u64)
12MoveLoc[9](Arg9: u64)
13MoveLoc[10](Arg10: u64)
14CopyLoc[11](Arg11: &mut TxContext)
15Call staking_inner::create_pool(&mut StakingInnerV1, String, String, NodeMetadata, vector<u8>, vector<u8>, vector<u8>, u16, u64, u64, u64, &mut TxContext): ID
16StLoc[13](loc1: ID)
17CopyLoc[13](loc1: ID)
18CopyLoc[11](Arg11: &mut TxContext)
19Call storage_node::new_cap(ID, &mut TxContext): StorageNodeCap
20StLoc[12](loc0: StorageNodeCap)
21ImmBorrowLoc[12](loc0: StorageNodeCap)
22Call object::id<StorageNodeCap>(&StorageNodeCap): ID
23Call auth::authorized_object(ID): Authorized
24StLoc[14](loc2: Authorized)
25MoveLoc[15](loc3: &mut StakingInnerV1)
26MoveLoc[13](loc1: ID)
27MoveLoc[11](Arg11: &mut TxContext)
28FreezeRef
29Call auth::authenticate_sender(&TxContext): Authenticated
30MoveLoc[14](loc2: Authorized)
31Call staking_inner::set_commission_receiver(&mut StakingInnerV1, ID, Authenticated, Authorized)
32MoveLoc[12](loc0: StorageNodeCap)
33Ret
}
public set_next_commission(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: u16) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: u16)
4Call staking_inner::set_next_commission(&mut StakingInnerV1, &StorageNodeCap, u16)
5Ret
}
public collect_commission(Arg0: &mut Staking, Arg1: ID, Arg2: Authenticated, Arg3: &mut TxContext): Coin<WAL> {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: ID)
3MoveLoc[2](Arg2: Authenticated)
4Call staking_inner::collect_commission(&mut StakingInnerV1, ID, Authenticated): Balance<WAL>
5MoveLoc[3](Arg3: &mut TxContext)
6Call coin::from_balance<WAL>(Balance<WAL>, &mut TxContext): Coin<WAL>
7Ret
}
public set_commission_receiver(Arg0: &mut Staking, Arg1: ID, Arg2: Authenticated, Arg3: Authorized) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: ID)
3MoveLoc[2](Arg2: Authenticated)
4MoveLoc[3](Arg3: Authorized)
5Call staking_inner::set_commission_receiver(&mut StakingInnerV1, ID, Authenticated, Authorized)
6Ret
}
public set_governance_authorized(Arg0: &mut Staking, Arg1: ID, Arg2: Authenticated, Arg3: Authorized) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: ID)
3MoveLoc[2](Arg2: Authenticated)
4MoveLoc[3](Arg3: Authorized)
5Call staking_inner::set_governance_authorized(&mut StakingInnerV1, ID, Authenticated, Authorized)
6Ret
}
public(friend) check_governance_authorization(Arg0: &Staking, Arg1: ID, Arg2: Authenticated): bool {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2MoveLoc[1](Arg1: ID)
3MoveLoc[2](Arg2: Authenticated)
4Call staking_inner::check_governance_authorization(&StakingInnerV1, ID, Authenticated): bool
5Ret
}
public(friend) get_current_node_weight(Arg0: &Staking, Arg1: ID): u16 {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2MoveLoc[1](Arg1: ID)
3Call staking_inner::get_current_node_weight(&StakingInnerV1, ID): u16
4Ret
}
public committee(Arg0: &Staking): &Committee {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2Call staking_inner::committee(&StakingInnerV1): &Committee
3Ret
}
public previous_committee(Arg0: &Staking): &Committee {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2Call staking_inner::previous_committee(&StakingInnerV1): &Committee
3Ret
}
public compute_next_committee(Arg0: &Staking): Committee {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2Call staking_inner::compute_next_committee(&StakingInnerV1): Committee
3Ret
}
public set_storage_price_vote(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: u64)
4Call staking_inner::set_storage_price_vote(&mut StakingInnerV1, &StorageNodeCap, u64)
5Ret
}
public set_write_price_vote(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: u64)
4Call staking_inner::set_write_price_vote(&mut StakingInnerV1, &StorageNodeCap, u64)
5Ret
}
public set_node_capacity_vote(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: u64)
4Call staking_inner::set_node_capacity_vote(&mut StakingInnerV1, &StorageNodeCap, u64)
5Ret
}
public update_prices(Arg0: &mut Staking, Arg1: &mut System) {
L2: loc0: u64
L3: loc1: u64
B0:
0CopyLoc[0](Arg0: &mut Staking)
1FreezeRef
2Call inner(&Staking): &StakingInnerV1
3Call staking_inner::recalculate_prices(&StakingInnerV1): u64 * u64
4StLoc[3](loc1: u64)
5StLoc[2](loc0: u64)
6CopyLoc[1](Arg1: &mut System)
7CopyLoc[2](loc0: u64)
8Call system::set_storage_price(&mut System, u64)
9MoveLoc[1](Arg1: &mut System)
10CopyLoc[3](loc1: u64)
11Call system::set_write_price(&mut System, u64)
12MoveLoc[0](Arg0: &mut Staking)
13FreezeRef
14Call inner(&Staking): &StakingInnerV1
15Call staking_inner::epoch(&StakingInnerV1): u32
16MoveLoc[2](loc0: u64)
17MoveLoc[3](loc1: u64)
18Call events::emit_prices_updated(u32, u64, u64)
19Ret
}
public node_metadata(Arg0: &Staking, Arg1: ID): NodeMetadata {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2MoveLoc[1](Arg1: ID)
3Call staking_inner::node_metadata(&StakingInnerV1, ID): NodeMetadata
4Ret
}
public set_next_public_key(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: vector<u8>)
4MoveLoc[3](Arg3: vector<u8>)
5MoveLoc[4](Arg4: &mut TxContext)
6FreezeRef
7Call staking_inner::set_next_public_key(&mut StakingInnerV1, &StorageNodeCap, vector<u8>, vector<u8>, &TxContext)
8Ret
}
public set_name(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: String) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: String)
4Call staking_inner::set_name(&mut StakingInnerV1, &StorageNodeCap, String)
5Ret
}
public set_network_address(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: String) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: String)
4Call staking_inner::set_network_address(&mut StakingInnerV1, &StorageNodeCap, String)
5Ret
}
public set_network_public_key(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: vector<u8>) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: vector<u8>)
4Call staking_inner::set_network_public_key(&mut StakingInnerV1, &StorageNodeCap, vector<u8>)
5Ret
}
public set_node_metadata(Arg0: &mut Staking, Arg1: &StorageNodeCap, Arg2: NodeMetadata) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3MoveLoc[2](Arg2: NodeMetadata)
4Call staking_inner::set_node_metadata(&mut StakingInnerV1, &StorageNodeCap, NodeMetadata)
5Ret
}
public voting_end(Arg0: &mut Staking, Arg1: &Clock) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &Clock)
3Call staking_inner::voting_end(&mut StakingInnerV1, &Clock)
4Ret
}
public initiate_epoch_change(Arg0: &mut Staking, Arg1: &mut System, Arg2: &Clock) {
B0:
0LdConst[2](u64: 2)
1Abort
}
public initiate_epoch_change_v2(Arg0: &mut Staking, Arg1: &mut System, Arg2: &mut ProtectedTreasury, Arg3: &Clock, Arg4: &mut TxContext) {
L5: loc0: Balance<WAL>
L6: loc1: VecMap<ID, Balance<WAL>>
L7: loc2: &mut StakingInnerV1
B0:
0CopyLoc[1](Arg1: &mut System)
1Call system::extract_burn_balance(&mut System): Balance<WAL>
2StLoc[5](loc0: Balance<WAL>)
3MoveLoc[2](Arg2: &mut ProtectedTreasury)
4MoveLoc[5](loc0: Balance<WAL>)
5MoveLoc[4](Arg4: &mut TxContext)
6Call coin::from_balance<WAL>(Balance<WAL>, &mut TxContext): Coin<WAL>
7Call wal::burn(&mut ProtectedTreasury, Coin<WAL>)
8CopyLoc[0](Arg0: &mut Staking)
9Call inner_mut(&mut Staking): &mut StakingInnerV1
10StLoc[7](loc2: &mut StakingInnerV1)
11CopyLoc[1](Arg1: &mut System)
12CopyLoc[7](loc2: &mut StakingInnerV1)
13Call staking_inner::next_bls_committee(&mut StakingInnerV1): BlsCommittee
14CopyLoc[7](loc2: &mut StakingInnerV1)
15FreezeRef
16Call staking_inner::next_epoch_params(&StakingInnerV1): &EpochParams
17Call system::advance_epoch(&mut System, BlsCommittee, &EpochParams): VecMap<ID, Balance<WAL>>
18StLoc[6](loc1: VecMap<ID, Balance<WAL>>)
19MoveLoc[7](loc2: &mut StakingInnerV1)
20MoveLoc[3](Arg3: &Clock)
21MoveLoc[6](loc1: VecMap<ID, Balance<WAL>>)
22Call staking_inner::initiate_epoch_change(&mut StakingInnerV1, &Clock, VecMap<ID, Balance<WAL>>)
23MoveLoc[0](Arg0: &mut Staking)
24MoveLoc[1](Arg1: &mut System)
25Call update_prices(&mut Staking, &mut System)
26Ret
}
public epoch_sync_done(Arg0: &mut Staking, Arg1: &mut StorageNodeCap, Arg2: u32, Arg3: &Clock) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &mut StorageNodeCap)
3MoveLoc[2](Arg2: u32)
4MoveLoc[3](Arg3: &Clock)
5Call staking_inner::epoch_sync_done(&mut StakingInnerV1, &mut StorageNodeCap, u32, &Clock)
6Ret
}
public stake_with_pool(Arg0: &mut Staking, Arg1: Coin<WAL>, Arg2: ID, Arg3: &mut TxContext): StakedWal {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: Coin<WAL>)
3MoveLoc[2](Arg2: ID)
4MoveLoc[3](Arg3: &mut TxContext)
5Call staking_inner::stake_with_pool(&mut StakingInnerV1, Coin<WAL>, ID, &mut TxContext): StakedWal
6Ret
}
public request_withdraw_stake(Arg0: &mut Staking, Arg1: &mut StakedWal, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &mut StakedWal)
3MoveLoc[2](Arg2: &mut TxContext)
4Call staking_inner::request_withdraw_stake(&mut StakingInnerV1, &mut StakedWal, &mut TxContext)
5Ret
}
public withdraw_stake(Arg0: &mut Staking, Arg1: StakedWal, Arg2: &mut TxContext): Coin<WAL> {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: StakedWal)
3MoveLoc[2](Arg2: &mut TxContext)
4Call staking_inner::withdraw_stake(&mut StakingInnerV1, StakedWal, &mut TxContext): Coin<WAL>
5Ret
}
public try_join_active_set(Arg0: &mut Staking, Arg1: &StorageNodeCap) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: &StorageNodeCap)
3Call staking_inner::try_join_active_set(&mut StakingInnerV1, &StorageNodeCap)
4Ret
}
public(friend) burn_commission(Arg0: &mut Staking, Arg1: ID, Arg2: &mut ProtectedTreasury, Arg3: &mut TxContext) {
L4: loc0: Balance<WAL>
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: ID)
3Call staking_inner::extract_commission_to_burn(&mut StakingInnerV1, ID): Balance<WAL>
4StLoc[4](loc0: Balance<WAL>)
5MoveLoc[2](Arg2: &mut ProtectedTreasury)
6MoveLoc[4](loc0: Balance<WAL>)
7MoveLoc[3](Arg3: &mut TxContext)
8Call coin::from_balance<WAL>(Balance<WAL>, &mut TxContext): Coin<WAL>
9Call wal::burn(&mut ProtectedTreasury, Coin<WAL>)
10Ret
}
public add_commission_to_pools(Arg0: &mut Staking, Arg1: vector<ID>, Arg2: vector<Balance<WAL>>) {
B0:
0MoveLoc[0](Arg0: &mut Staking)
1Call inner_mut(&mut Staking): &mut StakingInnerV1
2MoveLoc[1](Arg1: vector<ID>)
3MoveLoc[2](Arg2: vector<Balance<WAL>>)
4Call staking_inner::add_commission_to_pools(&mut StakingInnerV1, vector<ID>, vector<Balance<WAL>>)
5Ret
}
public(friend) package_id(Arg0: &Staking): ID {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[1](Staking.package_id: ID)
2ReadRef
3Ret
}
public(friend) version(Arg0: &Staking): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1ImmBorrowField[2](Staking.version: u64)
2ReadRef
3Ret
}
public epoch(Arg0: &Staking): u32 {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2Call staking_inner::epoch(&StakingInnerV1): u32
3Ret
}
public(friend) is_quorum(Arg0: &Staking, Arg1: u16): bool {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2MoveLoc[1](Arg1: u16)
3Call staking_inner::is_quorum(&StakingInnerV1, u16): bool
4Ret
}
public calculate_rewards(Arg0: &Staking, Arg1: ID, Arg2: u64, Arg3: u32, Arg4: u32): u64 {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2MoveLoc[1](Arg1: ID)
3MoveLoc[2](Arg2: u64)
4MoveLoc[3](Arg3: u32)
5MoveLoc[4](Arg4: u32)
6Call staking_inner::calculate_rewards(&StakingInnerV1, ID, u64, u32, u32): u64
7Ret
}
public can_withdraw_staked_wal_early(Arg0: &Staking, Arg1: &StakedWal): bool {
B0:
0MoveLoc[0](Arg0: &Staking)
1Call inner(&Staking): &StakingInnerV1
2MoveLoc[1](Arg1: &StakedWal)
3Call staking_inner::can_withdraw_staked_wal_early(&StakingInnerV1, &StakedWal): bool
4Ret
}
public(friend) set_new_package_id(Arg0: &mut Staking, Arg1: ID) {
B0:
0MoveLoc[1](Arg1: ID)
1Call option::some<ID>(ID): Option<ID>
2MoveLoc[0](Arg0: &mut Staking)
3MutBorrowField[3](Staking.new_package_id: Option<ID>)
4WriteRef
5Ret
}
entry set_migration_epoch(Arg0: &mut Staking) {
L1: loc0: u32
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[2](Staking.version: u64)
2ReadRef
3LdConst[3](u64: 4)
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &mut Staking)
8Pop
9LdConst[0](u64: 0)
10Abort
B3:
11CopyLoc[0](Arg0: &mut Staking)
12ImmBorrowField[0](Staking.id: UID)
13LdConst[4](vector<u8>: "mig..)
14Call dynamic_field::exists<vector<u8>>(&UID, vector<u8>): bool
15BrFalse(19)
B4:
16MoveLoc[0](Arg0: &mut Staking)
17Pop
18Ret
B5:
19CopyLoc[0](Arg0: &mut Staking)
20FreezeRef
21Call inner_without_version_check(&Staking): &StakingInnerV1
22Call staking_inner::epoch(&StakingInnerV1): u32
23LdU32(1)
24Add
25StLoc[1](loc0: u32)
26MoveLoc[0](Arg0: &mut Staking)
27MutBorrowField[0](Staking.id: UID)
28LdConst[4](vector<u8>: "mig..)
29MoveLoc[1](loc0: u32)
30Call dynamic_field::add<vector<u8>, u32>(&mut UID, vector<u8>, u32)
31Ret
}
public(friend) migrate(Arg0: &mut Staking) {
L1: loc0: StakingInnerV1
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[2](Staking.version: u64)
2ReadRef
3LdConst[3](u64: 4)
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &mut Staking)
8Pop
9LdConst[0](u64: 0)
10Abort
B3:
11LdConst[3](u64: 4)
12LdU64(4)
13Eq
14BrFalse(16)
B4:
15Branch(20)
B5:
16MoveLoc[0](Arg0: &mut Staking)
17Pop
18LdConst[0](u64: 0)
19Abort
B6:
20CopyLoc[0](Arg0: &mut Staking)
21MutBorrowField[0](Staking.id: UID)
22CopyLoc[0](Arg0: &mut Staking)
23ImmBorrowField[2](Staking.version: u64)
24ReadRef
25Call dynamic_field::remove<u64, StakingInnerV1>(&mut UID, u64): StakingInnerV1
26StLoc[1](loc0: StakingInnerV1)
27CopyLoc[0](Arg0: &mut Staking)
28MutBorrowField[0](Staking.id: UID)
29LdConst[3](u64: 4)
30MoveLoc[1](loc0: StakingInnerV1)
31Call dynamic_field::add<u64, StakingInnerV1>(&mut UID, u64, StakingInnerV1)
32LdConst[3](u64: 4)
33CopyLoc[0](Arg0: &mut Staking)
34MutBorrowField[2](Staking.version: u64)
35WriteRef
36CopyLoc[0](Arg0: &mut Staking)
37ImmBorrowField[3](Staking.new_package_id: Option<ID>)
38Call option::is_some<ID>(&Option<ID>): bool
39BrFalse(41)
B7:
40Branch(45)
B8:
41MoveLoc[0](Arg0: &mut Staking)
42Pop
43LdConst[0](u64: 0)
44Abort
B9:
45CopyLoc[0](Arg0: &mut Staking)
46MutBorrowField[3](Staking.new_package_id: Option<ID>)
47Call option::extract<ID>(&mut Option<ID>): ID
48CopyLoc[0](Arg0: &mut Staking)
49MutBorrowField[1](Staking.package_id: ID)
50WriteRef
51MoveLoc[0](Arg0: &mut Staking)
52Call inner_mut(&mut Staking): &mut StakingInnerV1
53Call staking_inner::update_active_set_max_size(&mut StakingInnerV1)
54Ret
}
inner_mut(Arg0: &mut Staking): &mut StakingInnerV1 {
B0:
0CopyLoc[0](Arg0: &mut Staking)
1ImmBorrowField[2](Staking.version: u64)
2ReadRef
3LdConst[3](u64: 4)
4Eq
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &mut Staking)
8Pop
9LdConst[1](u64: 1)
10Abort
B3:
11MoveLoc[0](Arg0: &mut Staking)
12MutBorrowField[0](Staking.id: UID)
13LdConst[3](u64: 4)
14Call dynamic_field::borrow_mut<u64, StakingInnerV1>(&mut UID, u64): &mut StakingInnerV1
15Ret
}
inner(Arg0: &Staking): &StakingInnerV1 {
B0:
0CopyLoc[0](Arg0: &Staking)
1ImmBorrowField[2](Staking.version: u64)
2ReadRef
3LdConst[3](u64: 4)
4Eq
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &Staking)
8Pop
9LdConst[1](u64: 1)
10Abort
B3:
11MoveLoc[0](Arg0: &Staking)
12ImmBorrowField[0](Staking.id: UID)
13LdConst[3](u64: 4)
14Call dynamic_field::borrow<u64, StakingInnerV1>(&UID, u64): &StakingInnerV1
15Ret
}
inner_without_version_check(Arg0: &Staking): &StakingInnerV1 {
B0:
0CopyLoc[0](Arg0: &Staking)
1ImmBorrowField[0](Staking.id: UID)
2MoveLoc[0](Arg0: &Staking)
3ImmBorrowField[2](Staking.version: u64)
4ReadRef
5Call dynamic_field::borrow<u64, StakingInnerV1>(&UID, u64): &StakingInnerV1
6Ret
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
3 => u64: 4
4 => vector<u8>: "migration_epoch" // interpreted as UTF8 string
]
}