staking_pool

Move path: 0xfdc8…ea77::staking_pool
Functions: 420 public, 0 entry
Structs: 4
Friend modules: staking_inner

staking_pool

Bytecode2000 lines

The on-chain disassembly. Offsets are instruction numbers within each function.

// Move bytecode v7

module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.staking_pool {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::u64;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::bag;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

use 356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::auth;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::messages;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::node_metadata;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::pending_values;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::pool_exchange_rate;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::staked_wal;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::storage_node;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::walrus_context;

struct NewEpochCommissionBlockedForCollection has copy, drop, store {

dummy_field: bool

}

struct VotingParams has copy, drop, store {

storage_price: u64,

write_price: u64,

node_capacity: u64

}

struct StakingPool has store, key {

id: UID,

state: PoolState,

voting_params: VotingParams,

node_info: StorageNodeInfo,

activation_epoch: u32,

latest_epoch: u32,

wal_balance: u64,

num_shares: u64,

pending_shares_withdraw: PendingValues,

pre_active_withdrawals: PendingValues,

pending_commission_rate: PendingValues,

commission_rate: u16,

exchange_rates: Table<u32, PoolExchangeRate>,

pending_stake: PendingValues,

rewards_pool: Balance<WAL>,

commission: Balance<WAL>,

commission_receiver: Authorized,

governance_authorized: Authorized,

extra_fields: Bag

}

enum PoolState has copy, drop, store {

Active { },

Withdrawing { pos0: u32 },

Withdrawn { }

}

public(friend) new(Arg0: String, Arg1: String, Arg2: NodeMetadata, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: u16, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &WalrusContext, Arg11: &mut TxContext): StakingPool {

L12: loc0: ProofOfPossessionMessage

L13: loc1: u32

L14: loc2: PendingValues

L15: loc3: PendingValues

L16: loc4: PendingValues

L17: loc5: PendingValues

L18: loc6: Balance<WAL>

L19: loc7: Balance<WAL>

L20: loc8: Authorized

L21: loc9: u32

L22: loc10: Authorized

L23: loc11: Bag

L24: loc12: UID

L25: loc13: Table<u32, PoolExchangeRate>

L26: loc14: VotingParams

L27: loc15: StorageNodeInfo

L28: loc16: u16

L29: loc17: u32

L30: loc18: u32

L31: loc19: Table<u32, PoolExchangeRate>

L32: loc20: UID

L33: loc21: ID

B0:

0CopyLoc[11](Arg11: &mut TxContext)

1Call object::new(&mut TxContext): UID

2StLoc[32](loc20: UID)

3ImmBorrowLoc[32](loc20: UID)

4Call object::uid_to_inner(&UID): ID

5StLoc[33](loc21: ID)

6CopyLoc[10](Arg10: &WalrusContext)

7Call walrus_context::epoch(&WalrusContext): u32

8CopyLoc[11](Arg11: &mut TxContext)

9FreezeRef

10Call tx_context::sender(&TxContext): address

11CopyLoc[3](Arg3: vector<u8>)

12Call messages::new_proof_of_possession_msg(u32, address, vector<u8>): ProofOfPossessionMessage

13StLoc[12](loc0: ProofOfPossessionMessage)

14ImmBorrowLoc[12](loc0: ProofOfPossessionMessage)

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

16Call messages::verify_proof_of_possession(&ProofOfPossessionMessage, vector<u8>): bool

17BrFalse(19)

B1:

18Branch(25)

B2:

19MoveLoc[10](Arg10: &WalrusContext)

20Pop

21MoveLoc[11](Arg11: &mut TxContext)

22Pop

23LdConst[7](u64: 4)

24Abort

B3:

25ImmBorrowLoc[0](Arg0: String)

26Call string::length(&String): u64

27LdConst[0](u64: 100)

28Le

29BrFalse(31)

B4:

30Branch(37)

B5:

31MoveLoc[10](Arg10: &WalrusContext)

32Pop

33MoveLoc[11](Arg11: &mut TxContext)

34Pop

35LdConst[20](u64: 17)

36Abort

B6:

37ImmBorrowLoc[1](Arg1: String)

38Call string::length(&String): u64

39LdConst[1](u64: 259)

40Le

41BrFalse(43)

B7:

42Branch(49)

B8:

43MoveLoc[10](Arg10: &WalrusContext)

44Pop

45MoveLoc[11](Arg11: &mut TxContext)

46Pop

47LdConst[19](u64: 16)

48Abort

B9:

49CopyLoc[6](Arg6: u16)

50LdConst[2](u16: 10000)

51Le

52BrFalse(54)

B10:

53Branch(60)

B11:

54MoveLoc[10](Arg10: &WalrusContext)

55Pop

56MoveLoc[11](Arg11: &mut TxContext)

57Pop

58LdConst[17](u64: 14)

59Abort

B12:

60CopyLoc[10](Arg10: &WalrusContext)

61Call walrus_context::committee_selected(&WalrusContext): bool

62BrFalse(69)

B13:

63CopyLoc[10](Arg10: &WalrusContext)

64Call walrus_context::epoch(&WalrusContext): u32

65LdU32(1)

66Add

67StLoc[21](loc9: u32)

68Branch(72)

B14:

69CopyLoc[10](Arg10: &WalrusContext)

70Call walrus_context::epoch(&WalrusContext): u32

71StLoc[21](loc9: u32)

B15:

72MoveLoc[21](loc9: u32)

73StLoc[30](loc18: u32)

74CopyLoc[11](Arg11: &mut TxContext)

75Call table::new<u32, PoolExchangeRate>(&mut TxContext): Table<u32, PoolExchangeRate>

76StLoc[31](loc19: Table<u32, PoolExchangeRate>)

77MutBorrowLoc[31](loc19: Table<u32, PoolExchangeRate>)

78CopyLoc[30](loc18: u32)

79Call pool_exchange_rate::flat(): PoolExchangeRate

80Call table::add<u32, PoolExchangeRate>(&mut Table<u32, PoolExchangeRate>, u32, PoolExchangeRate)

81MoveLoc[32](loc20: UID)

82StLoc[24](loc12: UID)

83MoveLoc[31](loc19: Table<u32, PoolExchangeRate>)

84StLoc[25](loc13: Table<u32, PoolExchangeRate>)

85MoveLoc[7](Arg7: u64)

86MoveLoc[8](Arg8: u64)

87MoveLoc[9](Arg9: u64)

88Pack[1](VotingParams)

89StLoc[26](loc14: VotingParams)

90MoveLoc[0](Arg0: String)

91MoveLoc[33](loc21: ID)

92MoveLoc[1](Arg1: String)

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

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

95MoveLoc[2](Arg2: NodeMetadata)

96CopyLoc[11](Arg11: &mut TxContext)

97Call storage_node::new(String, ID, String, vector<u8>, vector<u8>, NodeMetadata, &mut TxContext): StorageNodeInfo

98StLoc[27](loc15: StorageNodeInfo)

99MoveLoc[6](Arg6: u16)

100StLoc[28](loc16: u16)

101MoveLoc[30](loc18: u32)

102StLoc[29](loc17: u32)

103MoveLoc[10](Arg10: &WalrusContext)

104Call walrus_context::epoch(&WalrusContext): u32

105StLoc[13](loc1: u32)

106Call pending_values::empty(): PendingValues

107StLoc[14](loc2: PendingValues)

108Call pending_values::empty(): PendingValues

109StLoc[15](loc3: PendingValues)

110Call pending_values::empty(): PendingValues

111StLoc[16](loc4: PendingValues)

112Call pending_values::empty(): PendingValues

113StLoc[17](loc5: PendingValues)

114Call balance::zero<WAL>(): Balance<WAL>

115StLoc[18](loc6: Balance<WAL>)

116Call balance::zero<WAL>(): Balance<WAL>

117StLoc[19](loc7: Balance<WAL>)

118CopyLoc[11](Arg11: &mut TxContext)

119FreezeRef

120Call tx_context::sender(&TxContext): address

121Call auth::authorized_address(address): Authorized

122StLoc[20](loc8: Authorized)

123CopyLoc[11](Arg11: &mut TxContext)

124FreezeRef

125Call tx_context::sender(&TxContext): address

126Call auth::authorized_address(address): Authorized

127StLoc[22](loc10: Authorized)

128MoveLoc[11](Arg11: &mut TxContext)

129Call bag::new(&mut TxContext): Bag

130StLoc[23](loc11: Bag)

131MoveLoc[24](loc12: UID)

132PackVariant(VariantHandleIndex(0))

133MoveLoc[26](loc14: VotingParams)

134MoveLoc[27](loc15: StorageNodeInfo)

135MoveLoc[29](loc17: u32)

136MoveLoc[13](loc1: u32)

137LdU64(0)

138LdU64(0)

139MoveLoc[15](loc3: PendingValues)

140MoveLoc[16](loc4: PendingValues)

141MoveLoc[17](loc5: PendingValues)

142MoveLoc[28](loc16: u16)

143MoveLoc[25](loc13: Table<u32, PoolExchangeRate>)

144MoveLoc[14](loc2: PendingValues)

145MoveLoc[18](loc6: Balance<WAL>)

146MoveLoc[19](loc7: Balance<WAL>)

147MoveLoc[20](loc8: Authorized)

148MoveLoc[22](loc10: Authorized)

149MoveLoc[23](loc11: Bag)

150Pack[2](StakingPool)

151Ret

}

public(friend) set_withdrawing(Arg0: &mut StakingPool, Arg1: &WalrusContext) {

B0:

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

1FreezeRef

2Call is_withdrawing(&StakingPool): bool

3Not

4BrFalse(6)

B1:

5Branch(12)

B2:

6MoveLoc[1](Arg1: &WalrusContext)

7Pop

8MoveLoc[0](Arg0: &mut StakingPool)

9Pop

10LdConst[8](u64: 5)

11Abort

B3:

12MoveLoc[1](Arg1: &WalrusContext)

13Call walrus_context::epoch(&WalrusContext): u32

14LdU32(1)

15Add

16PackVariant(VariantHandleIndex(1))

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

18MutBorrowField[0](StakingPool.state: PoolState)

19WriteRef

20Ret

}

public(friend) stake(Arg0: &mut StakingPool, Arg1: Balance<WAL>, Arg2: &WalrusContext, Arg3: &mut TxContext): StakedWal {

L4: loc0: u32

L5: loc1: u32

L6: loc2: u32

L7: loc3: u64

L8: loc4: StakedWal

B0:

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

1FreezeRef

2Call is_active(&StakingPool): bool

3BrFalse(5)

B1:

4Branch(13)

B2:

5MoveLoc[2](Arg2: &WalrusContext)

6Pop

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

8Pop

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

10Pop

11LdConst[9](u64: 6)

12Abort

B3:

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

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

15LdU64(0)

16Gt

17BrFalse(19)

B4:

18Branch(27)

B5:

19MoveLoc[2](Arg2: &WalrusContext)

20Pop

21MoveLoc[0](Arg0: &mut StakingPool)

22Pop

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

24Pop

25LdConst[10](u64: 7)

26Abort

B6:

27CopyLoc[2](Arg2: &WalrusContext)

28Call walrus_context::epoch(&WalrusContext): u32

29StLoc[6](loc2: u32)

30MoveLoc[2](Arg2: &WalrusContext)

31Call walrus_context::committee_selected(&WalrusContext): bool

32BrFalse(38)

B7:

33MoveLoc[6](loc2: u32)

34LdU32(2)

35Add

36StLoc[4](loc0: u32)

37Branch(42)

B8:

38MoveLoc[6](loc2: u32)

39LdU32(1)

40Add

41StLoc[4](loc0: u32)

B9:

42MoveLoc[4](loc0: u32)

43StLoc[5](loc1: u32)

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

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

46StLoc[7](loc3: u64)

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

48ImmBorrowField[1](StakingPool.id: UID)

49Call object::uid_to_inner(&UID): ID

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

51CopyLoc[5](loc1: u32)

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

53Call staked_wal::mint(ID, Balance<WAL>, u32, &mut TxContext): StakedWal

54StLoc[8](loc4: StakedWal)

55MoveLoc[0](Arg0: &mut StakingPool)

56MutBorrowField[2](StakingPool.pending_stake: PendingValues)

57MoveLoc[5](loc1: u32)

58MoveLoc[7](loc3: u64)

59Call pending_values::insert_or_add(&mut PendingValues, u32, u64)

60MoveLoc[8](loc4: StakedWal)

61Ret

}

public(friend) request_withdraw_stake(Arg0: &mut StakingPool, Arg1: &mut StakedWal, Arg2: bool, Arg3: bool, Arg4: &WalrusContext) {

L5: loc0: u32

L6: loc1: PoolExchangeRate

L7: loc2: u64

L8: loc3: u64

L9: loc4: u32

L10: loc5: u32

B0:

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

1FreezeRef

2Call staked_wal::value(&StakedWal): u64

3LdU64(0)

4Gt

5BrFalse(7)

B1:

6Branch(15)

B2:

7MoveLoc[4](Arg4: &WalrusContext)

8Pop

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

10Pop

11MoveLoc[0](Arg0: &mut StakingPool)

12Pop

13LdConst[10](u64: 7)

14Abort

B3:

15CopyLoc[1](Arg1: &mut StakedWal)

16FreezeRef

17Call staked_wal::node_id(&StakedWal): ID

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

19ImmBorrowField[1](StakingPool.id: UID)

20Call object::uid_to_inner(&UID): ID

21Eq

22BrFalse(24)

B4:

23Branch(32)

B5:

24MoveLoc[4](Arg4: &WalrusContext)

25Pop

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

27Pop

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

29Pop

30LdConst[12](u64: 9)

31Abort

B6:

32CopyLoc[1](Arg1: &mut StakedWal)

33FreezeRef

34Call staked_wal::is_staked(&StakedWal): bool

35BrFalse(37)

B7:

36Branch(45)

B8:

37MoveLoc[4](Arg4: &WalrusContext)

38Pop

39MoveLoc[1](Arg1: &mut StakedWal)

40Pop

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

42Pop

43LdConst[11](u64: 8)

44Abort

B9:

45CopyLoc[1](Arg1: &mut StakedWal)

46FreezeRef

47CopyLoc[3](Arg3: bool)

48CopyLoc[4](Arg4: &WalrusContext)

49Call staked_wal::can_withdraw_early(&StakedWal, bool, &WalrusContext): bool

50Not

51BrFalse(53)

B10:

52Branch(61)

B11:

53MoveLoc[4](Arg4: &WalrusContext)

54Pop

55MoveLoc[1](Arg1: &mut StakedWal)

56Pop

57MoveLoc[0](Arg0: &mut StakingPool)

58Pop

59LdConst[16](u64: 13)

60Abort

B12:

61CopyLoc[1](Arg1: &mut StakedWal)

62FreezeRef

63Call staked_wal::activation_epoch(&StakedWal): u32

64CopyLoc[4](Arg4: &WalrusContext)

65Call walrus_context::epoch(&WalrusContext): u32

66LdU32(1)

67Add

68Eq

69BrFalse(89)

B13:

70MoveLoc[4](Arg4: &WalrusContext)

71Pop

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

73FreezeRef

74Call staked_wal::activation_epoch(&StakedWal): u32

75LdU32(1)

76Add

77StLoc[9](loc4: u32)

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

79MutBorrowField[3](StakingPool.pre_active_withdrawals: PendingValues)

80CopyLoc[9](loc4: u32)

81CopyLoc[1](Arg1: &mut StakedWal)

82FreezeRef

83Call staked_wal::value(&StakedWal): u64

84Call pending_values::insert_or_add(&mut PendingValues, u32, u64)

85MoveLoc[1](Arg1: &mut StakedWal)

86MoveLoc[9](loc4: u32)

87Call staked_wal::set_withdrawing(&mut StakedWal, u32)

88Ret

B14:

89CopyLoc[1](Arg1: &mut StakedWal)

90FreezeRef

91Call staked_wal::activation_epoch(&StakedWal): u32

92CopyLoc[4](Arg4: &WalrusContext)

93Call walrus_context::epoch(&WalrusContext): u32

94Le

95BrFalse(97)

B15:

96Branch(105)

B16:

97MoveLoc[4](Arg4: &WalrusContext)

98Pop

99MoveLoc[1](Arg1: &mut StakedWal)

100Pop

101MoveLoc[0](Arg0: &mut StakingPool)

102Pop

103LdConst[15](u64: 12)

104Abort

B17:

105MoveLoc[3](Arg3: bool)

106BrFalse(113)

B18:

107MoveLoc[4](Arg4: &WalrusContext)

108Call walrus_context::epoch(&WalrusContext): u32

109LdU32(2)

110Add

111StLoc[5](loc0: u32)

112Branch(129)

B19:

113MoveLoc[2](Arg2: bool)

114BrFalse(116)

B20:

115Branch(124)

B21:

116MoveLoc[4](Arg4: &WalrusContext)

117Pop

118MoveLoc[1](Arg1: &mut StakedWal)

119Pop

120MoveLoc[0](Arg0: &mut StakingPool)

121Pop

122LdConst[16](u64: 13)

123Abort

B22:

124MoveLoc[4](Arg4: &WalrusContext)

125Call walrus_context::epoch(&WalrusContext): u32

126LdU32(1)

127Add

128StLoc[5](loc0: u32)

B23:

129MoveLoc[5](loc0: u32)

130StLoc[10](loc5: u32)

131CopyLoc[1](Arg1: &mut StakedWal)

132FreezeRef

133Call staked_wal::value(&StakedWal): u64

134StLoc[7](loc2: u64)

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

136FreezeRef

137CopyLoc[1](Arg1: &mut StakedWal)

138FreezeRef

139Call staked_wal::activation_epoch(&StakedWal): u32

140Call exchange_rate_at_epoch(&StakingPool, u32): PoolExchangeRate

141StLoc[6](loc1: PoolExchangeRate)

142ImmBorrowLoc[6](loc1: PoolExchangeRate)

143MoveLoc[7](loc2: u64)

144Call pool_exchange_rate::convert_to_share_amount(&PoolExchangeRate, u64): u64

145StLoc[8](loc3: u64)

146CopyLoc[8](loc3: u64)

147LdU64(0)

148Neq

149BrFalse(151)

B24:

150Branch(157)

B25:

151MoveLoc[1](Arg1: &mut StakedWal)

152Pop

153MoveLoc[0](Arg0: &mut StakingPool)

154Pop

155LdConst[21](u64: 18)

156Abort

B26:

157MoveLoc[0](Arg0: &mut StakingPool)

158MutBorrowField[4](StakingPool.pending_shares_withdraw: PendingValues)

159CopyLoc[10](loc5: u32)

160MoveLoc[8](loc3: u64)

161Call pending_values::insert_or_add(&mut PendingValues, u32, u64)

162MoveLoc[1](Arg1: &mut StakedWal)

163MoveLoc[10](loc5: u32)

164Call staked_wal::set_withdrawing(&mut StakedWal, u32)

165Ret

}

public(friend) withdraw_stake(Arg0: &mut StakingPool, Arg1: StakedWal, Arg2: bool, Arg3: bool, Arg4: &WalrusContext): Balance<WAL> {

L5: loc0: bool

L6: loc1: PoolExchangeRate

L7: loc2: u64

L8: loc3: u64

L9: loc4: u32

L10: loc5: Balance<WAL>

L11: loc6: u64

L12: loc7: u64

L13: loc8: u64

L14: loc9: Balance<WAL>

B0:

0ImmBorrowLoc[1](Arg1: StakedWal)

1Call staked_wal::value(&StakedWal): u64

2LdU64(0)

3Gt

4BrFalse(6)

B1:

5Branch(12)

B2:

6MoveLoc[4](Arg4: &WalrusContext)

7Pop

8MoveLoc[0](Arg0: &mut StakingPool)

9Pop

10LdConst[10](u64: 7)

11Abort

B3:

12ImmBorrowLoc[1](Arg1: StakedWal)

13Call staked_wal::node_id(&StakedWal): ID

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

15ImmBorrowField[1](StakingPool.id: UID)

16Call object::uid_to_inner(&UID): ID

17Eq

18BrFalse(20)

B4:

19Branch(26)

B5:

20MoveLoc[4](Arg4: &WalrusContext)

21Pop

22MoveLoc[0](Arg0: &mut StakingPool)

23Pop

24LdConst[12](u64: 9)

25Abort

B6:

26ImmBorrowLoc[1](Arg1: StakedWal)

27Call staked_wal::activation_epoch(&StakedWal): u32

28StLoc[9](loc4: u32)

29ImmBorrowLoc[1](Arg1: StakedWal)

30CopyLoc[3](Arg3: bool)

31CopyLoc[4](Arg4: &WalrusContext)

32Call staked_wal::can_withdraw_early(&StakedWal, bool, &WalrusContext): bool

33BrFalse(45)

B7:

34MoveLoc[4](Arg4: &WalrusContext)

35Pop

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

37MutBorrowField[2](StakingPool.pending_stake: PendingValues)

38MoveLoc[9](loc4: u32)

39ImmBorrowLoc[1](Arg1: StakedWal)

40Call staked_wal::value(&StakedWal): u64

41Call pending_values::reduce(&mut PendingValues, u32, u64)

42MoveLoc[1](Arg1: StakedWal)

43Call staked_wal::into_balance(StakedWal): Balance<WAL>

44Ret

B8:

45MoveLoc[2](Arg2: bool)

46Not

47BrFalse(58)

B9:

48MoveLoc[3](Arg3: bool)

49Not

50BrFalse(55)

B10:

51ImmBorrowLoc[1](Arg1: StakedWal)

52Call staked_wal::is_staked(&StakedWal): bool

53StLoc[5](loc0: bool)

54Branch(60)

B11:

55LdFalse

56StLoc[5](loc0: bool)

57Branch(60)

B12:

58LdFalse

59StLoc[5](loc0: bool)

B13:

60MoveLoc[5](loc0: bool)

61BrFalse(106)

B14:

62CopyLoc[9](loc4: u32)

63CopyLoc[4](Arg4: &WalrusContext)

64Call walrus_context::epoch(&WalrusContext): u32

65Gt

66BrFalse(78)

B15:

67MoveLoc[4](Arg4: &WalrusContext)

68Pop

69CopyLoc[0](Arg0: &mut StakingPool)

70MutBorrowField[2](StakingPool.pending_stake: PendingValues)

71MoveLoc[9](loc4: u32)

72ImmBorrowLoc[1](Arg1: StakedWal)

73Call staked_wal::value(&StakedWal): u64

74Call pending_values::reduce(&mut PendingValues, u32, u64)

75LdU64(0)

76StLoc[7](loc2: u64)

77Branch(103)

B16:

78CopyLoc[0](Arg0: &mut StakingPool)

79FreezeRef

80CopyLoc[9](loc4: u32)

81Call exchange_rate_at_epoch(&StakingPool, u32): PoolExchangeRate

82StLoc[6](loc1: PoolExchangeRate)

83ImmBorrowLoc[6](loc1: PoolExchangeRate)

84ImmBorrowLoc[1](Arg1: StakedWal)

85Call staked_wal::value(&StakedWal): u64

86Call pool_exchange_rate::convert_to_share_amount(&PoolExchangeRate, u64): u64

87StLoc[13](loc8: u64)

88CopyLoc[0](Arg0: &mut StakingPool)

89MutBorrowField[4](StakingPool.pending_shares_withdraw: PendingValues)

90CopyLoc[4](Arg4: &WalrusContext)

91Call walrus_context::epoch(&WalrusContext): u32

92MoveLoc[13](loc8: u64)

93Call pending_values::insert_or_add(&mut PendingValues, u32, u64)

94CopyLoc[0](Arg0: &mut StakingPool)

95FreezeRef

96ImmBorrowLoc[1](Arg1: StakedWal)

97Call staked_wal::value(&StakedWal): u64

98MoveLoc[9](loc4: u32)

99MoveLoc[4](Arg4: &WalrusContext)

100Call walrus_context::epoch(&WalrusContext): u32

101Call calculate_rewards(&StakingPool, u64, u32, u32): u64

102StLoc[7](loc2: u64)

B17:

103MoveLoc[7](loc2: u64)

104StLoc[8](loc3: u64)

105Branch(148)

B18:

106ImmBorrowLoc[1](Arg1: StakedWal)

107Call staked_wal::is_withdrawing(&StakedWal): bool

108BrFalse(110)

B19:

109Branch(116)

B20:

110MoveLoc[4](Arg4: &WalrusContext)

111Pop

112MoveLoc[0](Arg0: &mut StakingPool)

113Pop

114LdConst[13](u64: 10)

115Abort

B21:

116ImmBorrowLoc[1](Arg1: StakedWal)

117Call staked_wal::withdraw_epoch(&StakedWal): u32

118CopyLoc[4](Arg4: &WalrusContext)

119Call walrus_context::epoch(&WalrusContext): u32

120Le

121BrFalse(123)

B22:

122Branch(129)

B23:

123MoveLoc[4](Arg4: &WalrusContext)

124Pop

125MoveLoc[0](Arg0: &mut StakingPool)

126Pop

127LdConst[14](u64: 11)

128Abort

B24:

129CopyLoc[9](loc4: u32)

130MoveLoc[4](Arg4: &WalrusContext)

131Call walrus_context::epoch(&WalrusContext): u32

132Le

133BrFalse(135)

B25:

134Branch(139)

B26:

135MoveLoc[0](Arg0: &mut StakingPool)

136Pop

137LdConst[15](u64: 12)

138Abort

B27:

139CopyLoc[0](Arg0: &mut StakingPool)

140FreezeRef

141ImmBorrowLoc[1](Arg1: StakedWal)

142Call staked_wal::value(&StakedWal): u64

143MoveLoc[9](loc4: u32)

144ImmBorrowLoc[1](Arg1: StakedWal)

145Call staked_wal::withdraw_epoch(&StakedWal): u32

146Call calculate_rewards(&StakingPool, u64, u32, u32): u64

147StLoc[8](loc3: u64)

B28:

148MoveLoc[8](loc3: u64)

149StLoc[11](loc6: u64)

150MoveLoc[1](Arg1: StakedWal)

151Call staked_wal::into_balance(StakedWal): Balance<WAL>

152StLoc[10](loc5: Balance<WAL>)

153MoveLoc[11](loc6: u64)

154CopyLoc[0](Arg0: &mut StakingPool)

155ImmBorrowField[5](StakingPool.rewards_pool: Balance<WAL>)

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

157Call u64::min(u64, u64): u64

158StLoc[12](loc7: u64)

159MoveLoc[0](Arg0: &mut StakingPool)

160MutBorrowField[5](StakingPool.rewards_pool: Balance<WAL>)

161MoveLoc[12](loc7: u64)

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

163StLoc[14](loc9: Balance<WAL>)

164MutBorrowLoc[14](loc9: Balance<WAL>)

165MoveLoc[10](loc5: Balance<WAL>)

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

167Pop

168MoveLoc[14](loc9: Balance<WAL>)

169Ret

}

public(friend) advance_epoch(Arg0: &mut StakingPool, Arg1: Balance<WAL>, Arg2: &WalrusContext) {

L3: loc0: bool

L4: loc1: Balance<WAL>

L5: loc2: u128

L6: loc3: u32

L7: loc4: Option<u64>

L8: loc5: u64

B0:

0CopyLoc[2](Arg2: &WalrusContext)

1Call walrus_context::epoch(&WalrusContext): u32

2StLoc[6](loc3: u32)

3CopyLoc[6](loc3: u32)

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

5ImmBorrowField[6](StakingPool.latest_epoch: u32)

6ReadRef

7Gt

8BrFalse(10)

B1:

9Branch(16)

B2:

10MoveLoc[2](Arg2: &WalrusContext)

11Pop

12MoveLoc[0](Arg0: &mut StakingPool)

13Pop

14LdConst[3](u64: 0)

15Abort

B3:

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

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

18LdU64(0)

19Eq

20BrFalse(24)

B4:

21LdTrue

22StLoc[3](loc0: bool)

23Branch(30)

B5:

24CopyLoc[0](Arg0: &mut StakingPool)

25ImmBorrowField[7](StakingPool.wal_balance: u64)

26ReadRef

27LdU64(0)

28Gt

29StLoc[3](loc0: bool)

B6:

30MoveLoc[3](loc0: bool)

31BrFalse(33)

B7:

32Branch(39)

B8:

33MoveLoc[2](Arg2: &WalrusContext)

34Pop

35MoveLoc[0](Arg0: &mut StakingPool)

36Pop

37LdConst[5](u64: 2)

38Abort

B9:

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

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

41CastU128

42CopyLoc[0](Arg0: &mut StakingPool)

43ImmBorrowField[8](StakingPool.commission_rate: u16)

44ReadRef

45CastU128

46Mul

47LdConst[2](u16: 10000)

48CastU128

49Div

50StLoc[5](loc2: u128)

51MutBorrowLoc[1](Arg1: Balance<WAL>)

52MoveLoc[5](loc2: u128)

53CastU64

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

55StLoc[4](loc1: Balance<WAL>)

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

57MoveLoc[4](loc1: Balance<WAL>)

58LdTrue

59Call add_commission(&mut StakingPool, Balance<WAL>, bool): u64

60Pop

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

62ImmBorrowField[9](StakingPool.pending_commission_rate: PendingValues)

63CopyLoc[6](loc3: u32)

64Call pending_values::latest_value_at(&PendingValues, u32): Option<u64>

65StLoc[7](loc4: Option<u64>)

66ImmBorrowLoc[7](loc4: Option<u64>)

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

68BrFalse(76)

B10:

69MoveLoc[7](loc4: Option<u64>)

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

71CastU16

72CopyLoc[0](Arg0: &mut StakingPool)

73MutBorrowField[8](StakingPool.commission_rate: u16)

74WriteRef

75Branch(78)

B11:

76MoveLoc[7](loc4: Option<u64>)

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

B12:

78CopyLoc[0](Arg0: &mut StakingPool)

79MutBorrowField[9](StakingPool.pending_commission_rate: PendingValues)

80CopyLoc[6](loc3: u32)

81Call pending_values::flush(&mut PendingValues, u32): u64

82Pop

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

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

85StLoc[8](loc5: u64)

86CopyLoc[0](Arg0: &mut StakingPool)

87MutBorrowField[5](StakingPool.rewards_pool: Balance<WAL>)

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

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

90Pop

91CopyLoc[0](Arg0: &mut StakingPool)

92ImmBorrowField[7](StakingPool.wal_balance: u64)

93ReadRef

94MoveLoc[8](loc5: u64)

95Add

96CopyLoc[0](Arg0: &mut StakingPool)

97MutBorrowField[7](StakingPool.wal_balance: u64)

98WriteRef

99MoveLoc[6](loc3: u32)

100CopyLoc[0](Arg0: &mut StakingPool)

101MutBorrowField[6](StakingPool.latest_epoch: u32)

102WriteRef

103CopyLoc[0](Arg0: &mut StakingPool)

104MutBorrowField[10](StakingPool.node_info: StorageNodeInfo)

105Call storage_node::rotate_public_key(&mut StorageNodeInfo)

106MoveLoc[0](Arg0: &mut StakingPool)

107MoveLoc[2](Arg2: &WalrusContext)

108Call process_pending_stake(&mut StakingPool, &WalrusContext)

109Ret

}

public(friend) add_commission(Arg0: &mut StakingPool, Arg1: Balance<WAL>, Arg2: bool): u64 {

L3: loc0: u64

L4: loc1: u64

B0:

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

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

2StLoc[3](loc0: u64)

3CopyLoc[0](Arg0: &mut StakingPool)

4MutBorrowField[11](StakingPool.commission: Balance<WAL>)

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

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

7StLoc[4](loc1: u64)

8MoveLoc[2](Arg2: bool)

9BrFalse(14)

B1:

10MoveLoc[0](Arg0: &mut StakingPool)

11MoveLoc[3](loc0: u64)

12Call increase_blocked_commission(&mut StakingPool, u64)

13Branch(16)

B2:

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

15Pop

B3:

16MoveLoc[4](loc1: u64)

17Ret

}

public(friend) extract_commission_to_burn(Arg0: &mut StakingPool): Balance<WAL> {

B0:

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

1Call clear_blocked_commission(&mut StakingPool)

2MoveLoc[0](Arg0: &mut StakingPool)

3MutBorrowField[11](StakingPool.commission: Balance<WAL>)

4Call balance::withdraw_all<WAL>(&mut Balance<WAL>): Balance<WAL>

5Ret

}

public(friend) process_pending_stake(Arg0: &mut StakingPool, Arg1: &WalrusContext) {

L2: loc0: u64

L3: loc1: PoolExchangeRate

L4: loc2: u32

L5: loc3: u32

L6: loc4: u32

L7: loc5: u64

L8: loc6: PoolExchangeRate

L9: loc7: u64

L10: loc8: u64

L11: loc9: u64

L12: loc10: VecMap<u32, u64>

L13: loc11: u64

L14: loc12: u64

L15: loc13: u64

L16: loc14: vector<u32>

B0:

0MoveLoc[1](Arg1: &WalrusContext)

1Call walrus_context::epoch(&WalrusContext): u32

2StLoc[5](loc3: u32)

3CopyLoc[0](Arg0: &mut StakingPool)

4ImmBorrowField[7](StakingPool.wal_balance: u64)

5ReadRef

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

7ImmBorrowField[12](StakingPool.num_shares: u64)

8ReadRef

9Call pool_exchange_rate::new(u64, u64): PoolExchangeRate

10StLoc[8](loc6: PoolExchangeRate)

11CopyLoc[0](Arg0: &mut StakingPool)

12MutBorrowField[13](StakingPool.exchange_rates: Table<u32, PoolExchangeRate>)

13CopyLoc[5](loc3: u32)

14CopyLoc[8](loc6: PoolExchangeRate)

15Call table::add<u32, PoolExchangeRate>(&mut Table<u32, PoolExchangeRate>, u32, PoolExchangeRate)

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

17ImmBorrowField[7](StakingPool.wal_balance: u64)

18ReadRef

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

20MutBorrowField[2](StakingPool.pending_stake: PendingValues)

21CopyLoc[5](loc3: u32)

22Call pending_values::flush(&mut PendingValues, u32): u64

23Add

24CopyLoc[0](Arg0: &mut StakingPool)

25MutBorrowField[7](StakingPool.wal_balance: u64)

26WriteRef

27LdU64(0)

28StLoc[11](loc9: u64)

29CopyLoc[0](Arg0: &mut StakingPool)

30ImmBorrowField[3](StakingPool.pre_active_withdrawals: PendingValues)

31ReadRef

32Call pending_values::unwrap(PendingValues): VecMap<u32, u64>

33StLoc[12](loc10: VecMap<u32, u64>)

34ImmBorrowLoc[12](loc10: VecMap<u32, u64>)

35Call vec_map::keys<u32, u64>(&VecMap<u32, u64>): vector<u32>

36StLoc[16](loc14: vector<u32>)

37MutBorrowLoc[16](loc14: vector<u32>)

38Call vector::reverse<u32>(&mut vector<u32>)

39ImmBorrowLoc[16](loc14: vector<u32>)

40VecLen(26)

41StLoc[2](loc0: u64)

42LdU64(0)

43StLoc[9](loc7: u64)

44MoveLoc[2](loc0: u64)

45StLoc[15](loc13: u64)

B1:

46CopyLoc[9](loc7: u64)

47CopyLoc[15](loc13: u64)

48Lt

49BrFalse(86)

B2:

50CopyLoc[9](loc7: u64)

51Pop

52MutBorrowLoc[16](loc14: vector<u32>)

53VecPopBack(26)

54StLoc[6](loc4: u32)

55CopyLoc[6](loc4: u32)

56CopyLoc[5](loc3: u32)

57Le

58BrFalse(81)

B3:

59MutBorrowLoc[12](loc10: VecMap<u32, u64>)

60ImmBorrowLoc[6](loc4: u32)

61Call vec_map::remove<u32, u64>(&mut VecMap<u32, u64>, &u32): u32 * u64

62StLoc[7](loc5: u64)

63Pop

64MoveLoc[6](loc4: u32)

65LdU32(1)

66Sub

67StLoc[4](loc2: u32)

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

69FreezeRef

70MoveLoc[4](loc2: u32)

71Call exchange_rate_at_epoch(&StakingPool, u32): PoolExchangeRate

72StLoc[3](loc1: PoolExchangeRate)

73ImmBorrowLoc[3](loc1: PoolExchangeRate)

74MoveLoc[7](loc5: u64)

75Call pool_exchange_rate::convert_to_share_amount(&PoolExchangeRate, u64): u64

76StLoc[13](loc11: u64)

77MoveLoc[11](loc9: u64)

78MoveLoc[13](loc11: u64)

79Add

80StLoc[11](loc9: u64)

B4:

81MoveLoc[9](loc7: u64)

82LdU64(1)

83Add

84StLoc[9](loc7: u64)

85Branch(46)

B5:

86MoveLoc[16](loc14: vector<u32>)

87VecUnpack(26, 0)

88CopyLoc[0](Arg0: &mut StakingPool)

89MutBorrowField[3](StakingPool.pre_active_withdrawals: PendingValues)

90CopyLoc[5](loc3: u32)

91Call pending_values::flush(&mut PendingValues, u32): u64

92Pop

93CopyLoc[0](Arg0: &mut StakingPool)

94MutBorrowField[4](StakingPool.pending_shares_withdraw: PendingValues)

95MoveLoc[5](loc3: u32)

96Call pending_values::flush(&mut PendingValues, u32): u64

97StLoc[14](loc12: u64)

98ImmBorrowLoc[8](loc6: PoolExchangeRate)

99MoveLoc[14](loc12: u64)

100MoveLoc[11](loc9: u64)

101Add

102Call pool_exchange_rate::convert_to_wal_amount(&PoolExchangeRate, u64): u64

103StLoc[10](loc8: u64)

104CopyLoc[0](Arg0: &mut StakingPool)

105ImmBorrowField[7](StakingPool.wal_balance: u64)

106ReadRef

107CopyLoc[10](loc8: u64)

108Ge

109BrFalse(111)

B6:

110Branch(115)

B7:

111MoveLoc[0](Arg0: &mut StakingPool)

112Pop

113LdConst[4](u64: 1)

114Abort

B8:

115CopyLoc[0](Arg0: &mut StakingPool)

116ImmBorrowField[7](StakingPool.wal_balance: u64)

117ReadRef

118MoveLoc[10](loc8: u64)

119Sub

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

121MutBorrowField[7](StakingPool.wal_balance: u64)

122WriteRef

123ImmBorrowLoc[8](loc6: PoolExchangeRate)

124CopyLoc[0](Arg0: &mut StakingPool)

125ImmBorrowField[7](StakingPool.wal_balance: u64)

126ReadRef

127Call pool_exchange_rate::convert_to_share_amount(&PoolExchangeRate, u64): u64

128MoveLoc[0](Arg0: &mut StakingPool)

129MutBorrowField[12](StakingPool.num_shares: u64)

130WriteRef

131Ret

}

public(friend) set_next_commission(Arg0: &mut StakingPool, Arg1: u16, Arg2: &WalrusContext) {

B0:

0CopyLoc[1](Arg1: u16)

1LdConst[2](u16: 10000)

2Le

3BrFalse(5)

B1:

4Branch(11)

B2:

5MoveLoc[2](Arg2: &WalrusContext)

6Pop

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

8Pop

9LdConst[17](u64: 14)

10Abort

B3:

11MoveLoc[0](Arg0: &mut StakingPool)

12MutBorrowField[9](StakingPool.pending_commission_rate: PendingValues)

13MoveLoc[2](Arg2: &WalrusContext)

14Call walrus_context::epoch(&WalrusContext): u32

15LdU32(2)

16Add

17MoveLoc[1](Arg1: u16)

18CastU64

19Call pending_values::insert_or_replace(&mut PendingValues, u32, u64)

20Ret

}

public(friend) set_next_storage_price(Arg0: &mut StakingPool, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

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

2MutBorrowField[14](StakingPool.voting_params: VotingParams)

3MutBorrowField[15](VotingParams.storage_price: u64)

4WriteRef

5Ret

}

public(friend) set_next_write_price(Arg0: &mut StakingPool, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

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

2MutBorrowField[14](StakingPool.voting_params: VotingParams)

3MutBorrowField[16](VotingParams.write_price: u64)

4WriteRef

5Ret

}

public(friend) set_next_node_capacity(Arg0: &mut StakingPool, Arg1: u64) {

B0:

0MoveLoc[1](Arg1: u64)

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

2MutBorrowField[14](StakingPool.voting_params: VotingParams)

3MutBorrowField[17](VotingParams.node_capacity: u64)

4WriteRef

5Ret

}

public(friend) set_next_public_key(Arg0: &mut StakingPool, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: &WalrusContext, Arg4: &TxContext) {

L5: loc0: ProofOfPossessionMessage

B0:

0MoveLoc[3](Arg3: &WalrusContext)

1Call walrus_context::epoch(&WalrusContext): u32

2MoveLoc[4](Arg4: &TxContext)

3Call tx_context::sender(&TxContext): address

4CopyLoc[1](Arg1: vector<u8>)

5Call messages::new_proof_of_possession_msg(u32, address, vector<u8>): ProofOfPossessionMessage

6StLoc[5](loc0: ProofOfPossessionMessage)

7ImmBorrowLoc[5](loc0: ProofOfPossessionMessage)

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

9Call messages::verify_proof_of_possession(&ProofOfPossessionMessage, vector<u8>): bool

10BrFalse(12)

B1:

11Branch(16)

B2:

12MoveLoc[0](Arg0: &mut StakingPool)

13Pop

14LdConst[7](u64: 4)

15Abort

B3:

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

17MutBorrowField[10](StakingPool.node_info: StorageNodeInfo)

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

19Call storage_node::set_next_public_key(&mut StorageNodeInfo, vector<u8>)

20Ret

}

public(friend) set_name(Arg0: &mut StakingPool, Arg1: String) {

B0:

0ImmBorrowLoc[1](Arg1: String)

1Call string::length(&String): u64

2LdConst[0](u64: 100)

3Le

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut StakingPool)

7Pop

8LdConst[20](u64: 17)

9Abort

B3:

10MoveLoc[0](Arg0: &mut StakingPool)

11MutBorrowField[10](StakingPool.node_info: StorageNodeInfo)

12MoveLoc[1](Arg1: String)

13Call storage_node::set_name(&mut StorageNodeInfo, String)

14Ret

}

public(friend) set_network_address(Arg0: &mut StakingPool, Arg1: String) {

B0:

0ImmBorrowLoc[1](Arg1: String)

1Call string::length(&String): u64

2LdConst[1](u64: 259)

3Le

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut StakingPool)

7Pop

8LdConst[19](u64: 16)

9Abort

B3:

10MoveLoc[0](Arg0: &mut StakingPool)

11MutBorrowField[10](StakingPool.node_info: StorageNodeInfo)

12MoveLoc[1](Arg1: String)

13Call storage_node::set_network_address(&mut StorageNodeInfo, String)

14Ret

}

public(friend) set_network_public_key(Arg0: &mut StakingPool, Arg1: vector<u8>) {

B0:

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

1MutBorrowField[10](StakingPool.node_info: StorageNodeInfo)

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

3Call storage_node::set_network_public_key(&mut StorageNodeInfo, vector<u8>)

4Ret

}

public(friend) set_node_metadata(Arg0: &mut StakingPool, Arg1: NodeMetadata) {

B0:

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

1MutBorrowField[10](StakingPool.node_info: StorageNodeInfo)

2MoveLoc[1](Arg1: NodeMetadata)

3Call storage_node::set_node_metadata(&mut StorageNodeInfo, NodeMetadata)

4Ret

}

public(friend) destroy_empty(Arg0: StakingPool) {

L1: loc0: Balance<WAL>

L2: loc1: Table<u32, PoolExchangeRate>

L3: loc2: Bag

L4: loc3: UID

L5: loc4: NewEpochCommissionBlockedForCollection

L6: loc5: StorageNodeInfo

L7: loc6: Balance<WAL>

B0:

0ImmBorrowLoc[0](Arg0: StakingPool)

1Call is_empty(&StakingPool): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[6](u64: 3)

5Abort

B3:

6MoveLoc[0](Arg0: StakingPool)

7Unpack[2](StakingPool)

8StLoc[3](loc2: Bag)

9Pop

10Pop

11StLoc[1](loc0: Balance<WAL>)

12StLoc[7](loc6: Balance<WAL>)

13Pop

14StLoc[2](loc1: Table<u32, PoolExchangeRate>)

15Pop

16Pop

17Pop

18Pop

19Pop

20Pop

21Pop

22Pop

23StLoc[6](loc5: StorageNodeInfo)

24Pop

25Pop

26StLoc[4](loc3: UID)

27LdFalse

28Pack[0](NewEpochCommissionBlockedForCollection)

29StLoc[5](loc4: NewEpochCommissionBlockedForCollection)

30ImmBorrowLoc[3](loc2: Bag)

31CopyLoc[5](loc4: NewEpochCommissionBlockedForCollection)

32Call bag::contains<NewEpochCommissionBlockedForCollection>(&Bag, NewEpochCommissionBlockedForCollection): bool

33BrFalse(38)

B4:

34MutBorrowLoc[3](loc2: Bag)

35MoveLoc[5](loc4: NewEpochCommissionBlockedForCollection)

36Call bag::remove<NewEpochCommissionBlockedForCollection, u64>(&mut Bag, NewEpochCommissionBlockedForCollection): u64

37Pop

B5:

38MoveLoc[4](loc3: UID)

39Call object::delete(UID)

40MoveLoc[2](loc1: Table<u32, PoolExchangeRate>)

41Call table::drop<u32, PoolExchangeRate>(Table<u32, PoolExchangeRate>)

42MoveLoc[6](loc5: StorageNodeInfo)

43Call storage_node::destroy(StorageNodeInfo)

44MoveLoc[1](loc0: Balance<WAL>)

45Call balance::destroy_zero<WAL>(Balance<WAL>)

46MoveLoc[7](loc6: Balance<WAL>)

47Call balance::destroy_zero<WAL>(Balance<WAL>)

48MoveLoc[3](loc2: Bag)

49Call bag::destroy_empty(Bag)

50Ret

}

public(friend) exchange_rate_at_epoch(Arg0: &StakingPool, Arg1: u32): PoolExchangeRate {

L2: loc0: u32

B0:

0CopyLoc[0](Arg0: &StakingPool)

1ImmBorrowField[18](StakingPool.activation_epoch: u32)

2ReadRef

3StLoc[2](loc0: u32)

B1:

4CopyLoc[1](Arg1: u32)

5CopyLoc[2](loc0: u32)

6Ge

7BrFalse(25)

B2:

8Branch(9)

B3:

9CopyLoc[0](Arg0: &StakingPool)

10ImmBorrowField[13](StakingPool.exchange_rates: Table<u32, PoolExchangeRate>)

11CopyLoc[1](Arg1: u32)

12Call table::contains<u32, PoolExchangeRate>(&Table<u32, PoolExchangeRate>, u32): bool

13BrFalse(20)

B4:

14MoveLoc[0](Arg0: &StakingPool)

15ImmBorrowField[13](StakingPool.exchange_rates: Table<u32, PoolExchangeRate>)

16MoveLoc[1](Arg1: u32)

17Call table::borrow<u32, PoolExchangeRate>(&Table<u32, PoolExchangeRate>, u32): &PoolExchangeRate

18ReadRef

19Ret

B5:

20MoveLoc[1](Arg1: u32)

21LdU32(1)

22Sub

23StLoc[1](Arg1: u32)

24Branch(4)

B6:

25MoveLoc[0](Arg0: &StakingPool)

26Pop

27Call pool_exchange_rate::flat(): PoolExchangeRate

28Ret

}

public(friend) wal_balance_at_epoch(Arg0: &StakingPool, Arg1: u32): u64 {

L2: loc0: u64

L3: loc1: vector<u32>

L4: loc2: PoolExchangeRate

L5: loc3: u32

L6: loc4: PoolExchangeRate

L7: loc5: u64

L8: loc6: u64

L9: loc7: &u32

L10: loc8: u64

L11: loc9: u64

L12: loc10: VecMap<u32, u64>

L13: loc11: u64

L14: loc12: u64

L15: loc13: u64

L16: loc14: &vector<u32>

L17: loc15: &u64

B0:

0CopyLoc[0](Arg0: &StakingPool)

1ImmBorrowField[7](StakingPool.wal_balance: u64)

2ReadRef

3CopyLoc[0](Arg0: &StakingPool)

4ImmBorrowField[12](StakingPool.num_shares: u64)

5ReadRef

6Call pool_exchange_rate::new(u64, u64): PoolExchangeRate

7StLoc[6](loc4: PoolExchangeRate)

8LdU64(0)

9StLoc[11](loc9: u64)

10CopyLoc[0](Arg0: &StakingPool)

11ImmBorrowField[3](StakingPool.pre_active_withdrawals: PendingValues)

12ReadRef

13Call pending_values::unwrap(PendingValues): VecMap<u32, u64>

14StLoc[12](loc10: VecMap<u32, u64>)

15ImmBorrowLoc[12](loc10: VecMap<u32, u64>)

16Call vec_map::keys<u32, u64>(&VecMap<u32, u64>): vector<u32>

17StLoc[3](loc1: vector<u32>)

18ImmBorrowLoc[3](loc1: vector<u32>)

19StLoc[16](loc14: &vector<u32>)

20CopyLoc[16](loc14: &vector<u32>)

21VecLen(26)

22StLoc[2](loc0: u64)

23LdU64(0)

24StLoc[7](loc5: u64)

25MoveLoc[2](loc0: u64)

26StLoc[15](loc13: u64)

B1:

27CopyLoc[7](loc5: u64)

28CopyLoc[15](loc13: u64)

29Lt

30BrFalse(72)

B2:

31CopyLoc[7](loc5: u64)

32StLoc[8](loc6: u64)

33CopyLoc[16](loc14: &vector<u32>)

34MoveLoc[8](loc6: u64)

35VecImmBorrow(26)

36StLoc[9](loc7: &u32)

37CopyLoc[9](loc7: &u32)

38ReadRef

39CopyLoc[1](Arg1: u32)

40Le

41BrFalse(65)

B3:

42ImmBorrowLoc[12](loc10: VecMap<u32, u64>)

43CopyLoc[9](loc7: &u32)

44Call vec_map::get<u32, u64>(&VecMap<u32, u64>, &u32): &u64

45StLoc[17](loc15: &u64)

46MoveLoc[9](loc7: &u32)

47ReadRef

48LdU32(1)

49Sub

50StLoc[5](loc3: u32)

51CopyLoc[0](Arg0: &StakingPool)

52MoveLoc[5](loc3: u32)

53Call exchange_rate_at_epoch(&StakingPool, u32): PoolExchangeRate

54StLoc[4](loc2: PoolExchangeRate)

55ImmBorrowLoc[4](loc2: PoolExchangeRate)

56MoveLoc[17](loc15: &u64)

57ReadRef

58Call pool_exchange_rate::convert_to_share_amount(&PoolExchangeRate, u64): u64

59StLoc[13](loc11: u64)

60MoveLoc[11](loc9: u64)

61MoveLoc[13](loc11: u64)

62Add

63StLoc[11](loc9: u64)

64Branch(67)

B4:

65MoveLoc[9](loc7: &u32)

66Pop

B5:

67MoveLoc[7](loc5: u64)

68LdU64(1)

69Add

70StLoc[7](loc5: u64)

71Branch(27)

B6:

72MoveLoc[16](loc14: &vector<u32>)

73Pop

74CopyLoc[0](Arg0: &StakingPool)

75ImmBorrowField[4](StakingPool.pending_shares_withdraw: PendingValues)

76CopyLoc[1](Arg1: u32)

77Call pending_values::value_at(&PendingValues, u32): u64

78StLoc[14](loc12: u64)

79ImmBorrowLoc[6](loc4: PoolExchangeRate)

80MoveLoc[14](loc12: u64)

81MoveLoc[11](loc9: u64)

82Add

83Call pool_exchange_rate::convert_to_wal_amount(&PoolExchangeRate, u64): u64

84StLoc[10](loc8: u64)

85CopyLoc[0](Arg0: &StakingPool)

86ImmBorrowField[7](StakingPool.wal_balance: u64)

87ReadRef

88MoveLoc[0](Arg0: &StakingPool)

89ImmBorrowField[2](StakingPool.pending_stake: PendingValues)

90MoveLoc[1](Arg1: u32)

91Call pending_values::value_at(&PendingValues, u32): u64

92Add

93MoveLoc[10](loc8: u64)

94Sub

95Ret

}

public(friend) governance_authorized(Arg0: &StakingPool): &Authorized {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[19](StakingPool.governance_authorized: Authorized)

2Ret

}

public(friend) set_governance_authorized(Arg0: &mut StakingPool, Arg1: Authenticated, Arg2: Authorized) {

B0:

0ImmBorrowLoc[1](Arg1: Authenticated)

1CopyLoc[0](Arg0: &mut StakingPool)

2ImmBorrowField[19](StakingPool.governance_authorized: Authorized)

3Call auth::matches(&Authenticated, &Authorized): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut StakingPool)

7Pop

8LdConst[18](u64: 15)

9Abort

B3:

10MoveLoc[2](Arg2: Authorized)

11MoveLoc[0](Arg0: &mut StakingPool)

12MutBorrowField[19](StakingPool.governance_authorized: Authorized)

13WriteRef

14Ret

}

public(friend) commission_receiver(Arg0: &StakingPool): &Authorized {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[20](StakingPool.commission_receiver: Authorized)

2Ret

}

public(friend) set_commission_receiver(Arg0: &mut StakingPool, Arg1: Authenticated, Arg2: Authorized) {

B0:

0ImmBorrowLoc[1](Arg1: Authenticated)

1CopyLoc[0](Arg0: &mut StakingPool)

2ImmBorrowField[20](StakingPool.commission_receiver: Authorized)

3Call auth::matches(&Authenticated, &Authorized): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut StakingPool)

7Pop

8LdConst[18](u64: 15)

9Abort

B3:

10MoveLoc[2](Arg2: Authorized)

11MoveLoc[0](Arg0: &mut StakingPool)

12MutBorrowField[20](StakingPool.commission_receiver: Authorized)

13WriteRef

14Ret

}

public(friend) commission_rate(Arg0: &StakingPool): u16 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[8](StakingPool.commission_rate: u16)

2ReadRef

3Ret

}

public(friend) commission_amount(Arg0: &StakingPool): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[11](StakingPool.commission: Balance<WAL>)

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

3Ret

}

public(friend) collect_commission(Arg0: &mut StakingPool, Arg1: Authenticated): Balance<WAL> {

L2: loc0: u64

L3: loc1: u64

B0:

0ImmBorrowLoc[1](Arg1: Authenticated)

1CopyLoc[0](Arg0: &mut StakingPool)

2ImmBorrowField[20](StakingPool.commission_receiver: Authorized)

3Call auth::matches(&Authenticated, &Authorized): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut StakingPool)

7Pop

8LdConst[18](u64: 15)

9Abort

B3:

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

11FreezeRef

12Call get_blocked_commission_amount(&StakingPool): u64

13StLoc[2](loc0: u64)

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

15ImmBorrowField[11](StakingPool.commission: Balance<WAL>)

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

17StLoc[3](loc1: u64)

18CopyLoc[3](loc1: u64)

19CopyLoc[2](loc0: u64)

20Le

21BrFalse(26)

B4:

22MoveLoc[0](Arg0: &mut StakingPool)

23Pop

24Call balance::zero<WAL>(): Balance<WAL>

25Ret

B5:

26MoveLoc[0](Arg0: &mut StakingPool)

27MutBorrowField[11](StakingPool.commission: Balance<WAL>)

28MoveLoc[3](loc1: u64)

29MoveLoc[2](loc0: u64)

30Sub

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

32Ret

}

public(friend) increase_blocked_commission(Arg0: &mut StakingPool, Arg1: u64) {

L2: loc0: &mut u64

L3: loc1: NewEpochCommissionBlockedForCollection

B0:

0LdFalse

1Pack[0](NewEpochCommissionBlockedForCollection)

2StLoc[3](loc1: NewEpochCommissionBlockedForCollection)

3CopyLoc[0](Arg0: &mut StakingPool)

4ImmBorrowField[21](StakingPool.extra_fields: Bag)

5CopyLoc[3](loc1: NewEpochCommissionBlockedForCollection)

6Call bag::contains<NewEpochCommissionBlockedForCollection>(&Bag, NewEpochCommissionBlockedForCollection): bool

7BrFalse(20)

B1:

8MoveLoc[0](Arg0: &mut StakingPool)

9MutBorrowField[21](StakingPool.extra_fields: Bag)

10MoveLoc[3](loc1: NewEpochCommissionBlockedForCollection)

11Call bag::borrow_mut<NewEpochCommissionBlockedForCollection, u64>(&mut Bag, NewEpochCommissionBlockedForCollection): &mut u64

12StLoc[2](loc0: &mut u64)

13CopyLoc[2](loc0: &mut u64)

14ReadRef

15MoveLoc[1](Arg1: u64)

16Add

17MoveLoc[2](loc0: &mut u64)

18WriteRef

19Branch(25)

B2:

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

21MutBorrowField[21](StakingPool.extra_fields: Bag)

22MoveLoc[3](loc1: NewEpochCommissionBlockedForCollection)

23MoveLoc[1](Arg1: u64)

24Call bag::add<NewEpochCommissionBlockedForCollection, u64>(&mut Bag, NewEpochCommissionBlockedForCollection, u64)

B3:

25Ret

}

public(friend) clear_blocked_commission(Arg0: &mut StakingPool) {

L1: loc0: NewEpochCommissionBlockedForCollection

B0:

0LdFalse

1Pack[0](NewEpochCommissionBlockedForCollection)

2StLoc[1](loc0: NewEpochCommissionBlockedForCollection)

3CopyLoc[0](Arg0: &mut StakingPool)

4ImmBorrowField[21](StakingPool.extra_fields: Bag)

5CopyLoc[1](loc0: NewEpochCommissionBlockedForCollection)

6Call bag::contains<NewEpochCommissionBlockedForCollection>(&Bag, NewEpochCommissionBlockedForCollection): bool

7BrFalse(14)

B1:

8MoveLoc[0](Arg0: &mut StakingPool)

9MutBorrowField[21](StakingPool.extra_fields: Bag)

10MoveLoc[1](loc0: NewEpochCommissionBlockedForCollection)

11Call bag::remove<NewEpochCommissionBlockedForCollection, u64>(&mut Bag, NewEpochCommissionBlockedForCollection): u64

12Pop

13Branch(16)

B2:

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

15Pop

B3:

16Ret

}

get_blocked_commission_amount(Arg0: &StakingPool): u64 {

L1: loc0: u64

L2: loc1: NewEpochCommissionBlockedForCollection

B0:

0LdFalse

1Pack[0](NewEpochCommissionBlockedForCollection)

2StLoc[2](loc1: NewEpochCommissionBlockedForCollection)

3CopyLoc[0](Arg0: &StakingPool)

4ImmBorrowField[21](StakingPool.extra_fields: Bag)

5CopyLoc[2](loc1: NewEpochCommissionBlockedForCollection)

6Call bag::contains<NewEpochCommissionBlockedForCollection>(&Bag, NewEpochCommissionBlockedForCollection): bool

7BrFalse(15)

B1:

8MoveLoc[0](Arg0: &StakingPool)

9ImmBorrowField[21](StakingPool.extra_fields: Bag)

10MoveLoc[2](loc1: NewEpochCommissionBlockedForCollection)

11Call bag::borrow<NewEpochCommissionBlockedForCollection, u64>(&Bag, NewEpochCommissionBlockedForCollection): &u64

12ReadRef

13StLoc[1](loc0: u64)

14Branch(19)

B2:

15MoveLoc[0](Arg0: &StakingPool)

16Pop

17LdU64(0)

18StLoc[1](loc0: u64)

B3:

19MoveLoc[1](loc0: u64)

20Ret

}

public(friend) rewards_amount(Arg0: &StakingPool): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[5](StakingPool.rewards_pool: Balance<WAL>)

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

3Ret

}

public(friend) wal_balance(Arg0: &StakingPool): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[7](StakingPool.wal_balance: u64)

2ReadRef

3Ret

}

public(friend) storage_price(Arg0: &StakingPool): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[14](StakingPool.voting_params: VotingParams)

2ImmBorrowField[15](VotingParams.storage_price: u64)

3ReadRef

4Ret

}

public(friend) write_price(Arg0: &StakingPool): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[14](StakingPool.voting_params: VotingParams)

2ImmBorrowField[16](VotingParams.write_price: u64)

3ReadRef

4Ret

}

public(friend) node_capacity(Arg0: &StakingPool): u64 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[14](StakingPool.voting_params: VotingParams)

2ImmBorrowField[17](VotingParams.node_capacity: u64)

3ReadRef

4Ret

}

public(friend) activation_epoch(Arg0: &StakingPool): u32 {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[18](StakingPool.activation_epoch: u32)

2ReadRef

3Ret

}

public(friend) node_info(Arg0: &StakingPool): &StorageNodeInfo {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[10](StakingPool.node_info: StorageNodeInfo)

2Ret

}

public(friend) is_active(Arg0: &StakingPool): bool {

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[0](StakingPool.state: PoolState)

2ReadRef

3PackVariant(VariantHandleIndex(0))

4Eq

5Ret

}

public(friend) is_withdrawing(Arg0: &StakingPool): bool {

L1: loc0: bool

L2: loc1: &PoolState

L3: loc2: PoolState

B0:

0MoveLoc[0](Arg0: &StakingPool)

1ImmBorrowField[0](StakingPool.state: PoolState)

2ReadRef

3StLoc[3](loc2: PoolState)

4ImmBorrowLoc[3](loc2: PoolState)

5StLoc[2](loc1: &PoolState)

6CopyLoc[2](loc1: &PoolState)

7VariantSwitch(VariantJumpTableIndex(0))

B1:

8MoveLoc[2](loc1: &PoolState)

9Pop

10LdFalse

11StLoc[1](loc0: bool)

12Branch(26)

B2:

13MoveLoc[2](loc1: &PoolState)

14UnpackVariantImmRef(VariantHandleIndex(1))

15Pop

16MoveLoc[3](loc2: PoolState)

17UnpackVariant(VariantHandleIndex(1))

18Pop

19LdTrue

20StLoc[1](loc0: bool)

21Branch(26)

B3:

22MoveLoc[2](loc1: &PoolState)

23Pop

24LdFalse

25StLoc[1](loc0: bool)

B4:

26MoveLoc[1](loc0: bool)

27Ret

Jump tables:

[0]: variant_switch PoolState {

Variant0 => jump 8

Variant1 => jump 13

Variant2 => jump 22

}

public(friend) is_empty(Arg0: &StakingPool): bool {

L1: loc0: u64

L2: loc1: vector<u32>

L3: loc2: bool

L4: loc3: u64

L5: loc4: &u32

L6: loc5: u64

L7: loc6: u64

L8: loc7: u64

L9: loc8: VecMap<u32, u64>

L10: loc9: u64

L11: loc10: &vector<u32>

L12: loc11: &vector<u32>

B0:

0CopyLoc[0](Arg0: &StakingPool)

1ImmBorrowField[2](StakingPool.pending_stake: PendingValues)

2ReadRef

3Call pending_values::unwrap(PendingValues): VecMap<u32, u64>

4StLoc[9](loc8: VecMap<u32, u64>)

5ImmBorrowLoc[9](loc8: VecMap<u32, u64>)

6Call vec_map::keys<u32, u64>(&VecMap<u32, u64>): vector<u32>

7StLoc[2](loc1: vector<u32>)

8ImmBorrowLoc[2](loc1: vector<u32>)

9StLoc[11](loc10: &vector<u32>)

10LdU64(0)

11StLoc[4](loc3: u64)

12MoveLoc[11](loc10: &vector<u32>)

13StLoc[12](loc11: &vector<u32>)

14CopyLoc[12](loc11: &vector<u32>)

15VecLen(26)

16StLoc[1](loc0: u64)

17LdU64(0)

18StLoc[7](loc6: u64)

19MoveLoc[1](loc0: u64)

20StLoc[10](loc9: u64)

B1:

21CopyLoc[7](loc6: u64)

22CopyLoc[10](loc9: u64)

23Lt

24BrFalse(47)

B2:

25CopyLoc[7](loc6: u64)

26StLoc[6](loc5: u64)

27CopyLoc[12](loc11: &vector<u32>)

28MoveLoc[6](loc5: u64)

29VecImmBorrow(26)

30StLoc[5](loc4: &u32)

31ImmBorrowLoc[9](loc8: VecMap<u32, u64>)

32MoveLoc[5](loc4: &u32)

33Call vec_map::get<u32, u64>(&VecMap<u32, u64>, &u32): &u64

34ReadRef

35LdU64(0)

36Neq

37BrFalse(42)

B3:

38MoveLoc[4](loc3: u64)

39LdU64(1)

40Add

41StLoc[4](loc3: u64)

B4:

42MoveLoc[7](loc6: u64)

43LdU64(1)

44Add

45StLoc[7](loc6: u64)

46Branch(21)

B5:

47MoveLoc[12](loc11: &vector<u32>)

48Pop

49MoveLoc[4](loc3: u64)

50StLoc[8](loc7: u64)

51CopyLoc[0](Arg0: &StakingPool)

52ImmBorrowField[5](StakingPool.rewards_pool: Balance<WAL>)

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

54LdU64(0)

55Eq

56BrFalse(94)

B6:

57CopyLoc[0](Arg0: &StakingPool)

58ImmBorrowField[12](StakingPool.num_shares: u64)

59ReadRef

60LdU64(0)

61Eq

62BrFalse(89)

B7:

63Branch(64)

B8:

64CopyLoc[0](Arg0: &StakingPool)

65ImmBorrowField[11](StakingPool.commission: Balance<WAL>)

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

67LdU64(0)

68Eq

69BrFalse(84)

B9:

70MoveLoc[0](Arg0: &StakingPool)

71ImmBorrowField[7](StakingPool.wal_balance: u64)

72ReadRef

73LdU64(0)

74Eq

75BrFalse(81)

B10:

76MoveLoc[8](loc7: u64)

77LdU64(0)

78Eq

79StLoc[3](loc2: bool)

80Branch(98)

B11:

81LdFalse

82StLoc[3](loc2: bool)

83Branch(98)

B12:

84MoveLoc[0](Arg0: &StakingPool)

85Pop

86LdFalse

87StLoc[3](loc2: bool)

88Branch(98)

B13:

89MoveLoc[0](Arg0: &StakingPool)

90Pop

91LdFalse

92StLoc[3](loc2: bool)

93Branch(98)

B14:

94MoveLoc[0](Arg0: &StakingPool)

95Pop

96LdFalse

97StLoc[3](loc2: bool)

B15:

98MoveLoc[3](loc2: bool)

99Ret

}

public(friend) calculate_rewards(Arg0: &StakingPool, Arg1: u64, Arg2: u32, Arg3: u32): u64 {

L4: loc0: PoolExchangeRate

L5: loc1: PoolExchangeRate

L6: loc2: u64

L7: loc3: u64

L8: loc4: u64

B0:

0CopyLoc[0](Arg0: &StakingPool)

1MoveLoc[2](Arg2: u32)

2Call exchange_rate_at_epoch(&StakingPool, u32): PoolExchangeRate

3StLoc[4](loc0: PoolExchangeRate)

4ImmBorrowLoc[4](loc0: PoolExchangeRate)

5CopyLoc[1](Arg1: u64)

6Call pool_exchange_rate::convert_to_share_amount(&PoolExchangeRate, u64): u64

7StLoc[7](loc3: u64)

8MoveLoc[0](Arg0: &StakingPool)

9MoveLoc[3](Arg3: u32)

10Call exchange_rate_at_epoch(&StakingPool, u32): PoolExchangeRate

11StLoc[5](loc1: PoolExchangeRate)

12ImmBorrowLoc[5](loc1: PoolExchangeRate)

13MoveLoc[7](loc3: u64)

14Call pool_exchange_rate::convert_to_wal_amount(&PoolExchangeRate, u64): u64

15StLoc[8](loc4: u64)

16CopyLoc[8](loc4: u64)

17CopyLoc[1](Arg1: u64)

18Ge

19BrFalse(25)

B1:

20MoveLoc[8](loc4: u64)

21MoveLoc[1](Arg1: u64)

22Sub

23StLoc[6](loc2: u64)

24Branch(27)

B2:

25LdU64(0)

26StLoc[6](loc2: u64)

B3:

27MoveLoc[6](loc2: u64)

28Ret

}

Constants [

0 => u64: 100

1 => u64: 259

2 => u16: 10000

3 => u64: 0

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 => u64: 11

15 => u64: 12

16 => u64: 13

17 => u64: 14

18 => u64: 15

19 => u64: 16

20 => u64: 17

21 => u64: 18

]

}