upgrade

Module0xfa65…814e

Move path: 0xfdc8…ea77::upgrade
Functions: 96 public, 0 entry
Structs: 4
Friend modules: init

upgrade

Bytecode547 lines

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

// Move bytecode v7

module fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77.upgrade {

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::auth;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::staking;

use fdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::system;

struct PackageDigest has copy, drop, store {

pos0: vector<u8>

}

struct UpgradeProposal has drop, store {

epoch: u32,

digest: PackageDigest,

version: u64,

voting_weight: u16,

voters: VecSet<ID>

}

struct UpgradeManager has key {

id: UID,

cap: UpgradeCap,

upgrade_proposals: Table<PackageDigest, UpgradeProposal>

}

struct EmergencyUpgradeCap has store, key {

id: UID,

upgrade_manager_id: ID

}

public(friend) new(Arg0: UpgradeCap, Arg1: &mut TxContext): EmergencyUpgradeCap {

L2: loc0: EmergencyUpgradeCap

L3: loc1: UpgradeManager

B0:

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

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

2MoveLoc[0](Arg0: UpgradeCap)

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

4Call table::new<PackageDigest, UpgradeProposal>(&mut TxContext): Table<PackageDigest, UpgradeProposal>

5Pack[2](UpgradeManager)

6StLoc[3](loc1: UpgradeManager)

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

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

9ImmBorrowLoc[3](loc1: UpgradeManager)

10Call object::id<UpgradeManager>(&UpgradeManager): ID

11Pack[3](EmergencyUpgradeCap)

12StLoc[2](loc0: EmergencyUpgradeCap)

13MoveLoc[3](loc1: UpgradeManager)

14Call transfer::share_object<UpgradeManager>(UpgradeManager)

15MoveLoc[2](loc0: EmergencyUpgradeCap)

16Ret

}

public vote_for_upgrade(Arg0: &mut UpgradeManager, Arg1: &Staking, Arg2: Authenticated, Arg3: ID, Arg4: vector<u8>) {

L5: loc0: bool

L6: loc1: &mut UpgradeProposal

L7: loc2: PackageDigest

L8: loc3: vector<u8>

L9: loc4: u32

L10: loc5: &mut UpgradeProposal

L11: loc6: UpgradeProposal

L12: loc7: &mut UpgradeProposal

L13: loc8: u16

B0:

0CopyLoc[1](Arg1: &Staking)

1CopyLoc[3](Arg3: ID)

2MoveLoc[2](Arg2: Authenticated)

3Call staking::check_governance_authorization(&Staking, ID, Authenticated): bool

4BrFalse(6)

B1:

5Branch(12)

B2:

6MoveLoc[1](Arg1: &Staking)

7Pop

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

9Pop

10LdConst[1](u64: 1)

11Abort

B3:

12CopyLoc[1](Arg1: &Staking)

13CopyLoc[3](Arg3: ID)

14Call staking::get_current_node_weight(&Staking, ID): u16

15StLoc[13](loc8: u16)

16CopyLoc[1](Arg1: &Staking)

17Call staking::epoch(&Staking): u32

18StLoc[9](loc4: u32)

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

20StLoc[8](loc3: vector<u8>)

21ImmBorrowLoc[8](loc3: vector<u8>)

22VecLen(28)

23LdU64(32)

24Eq

25BrFalse(27)

B4:

26Branch(33)

B5:

27MoveLoc[1](Arg1: &Staking)

28Pop

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

30Pop

31LdConst[3](u64: 3)

32Abort

B6:

33MoveLoc[8](loc3: vector<u8>)

34Pack[0](PackageDigest)

35StLoc[7](loc2: PackageDigest)

36CopyLoc[0](Arg0: &mut UpgradeManager)

37ImmBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

38CopyLoc[7](loc2: PackageDigest)

39Call table::contains<PackageDigest, UpgradeProposal>(&Table<PackageDigest, UpgradeProposal>, PackageDigest): bool

40BrFalse(83)

B7:

41CopyLoc[0](Arg0: &mut UpgradeManager)

42MutBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

43CopyLoc[7](loc2: PackageDigest)

44Call table::borrow_mut<PackageDigest, UpgradeProposal>(&mut Table<PackageDigest, UpgradeProposal>, PackageDigest): &mut UpgradeProposal

45StLoc[10](loc5: &mut UpgradeProposal)

46CopyLoc[10](loc5: &mut UpgradeProposal)

47ImmBorrowField[1](UpgradeProposal.epoch: u32)

48ReadRef

49CopyLoc[9](loc4: u32)

50Neq

51BrFalse(55)

B8:

52LdTrue

53StLoc[5](loc0: bool)

54Branch(65)

B9:

55CopyLoc[10](loc5: &mut UpgradeProposal)

56ImmBorrowField[2](UpgradeProposal.version: u64)

57ReadRef

58CopyLoc[0](Arg0: &mut UpgradeManager)

59ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

60Call package::version(&UpgradeCap): u64

61LdU64(1)

62Add

63Neq

64StLoc[5](loc0: bool)

B10:

65MoveLoc[5](loc0: bool)

66BrFalse(78)

B11:

67CopyLoc[9](loc4: u32)

68CopyLoc[7](loc2: PackageDigest)

69MoveLoc[0](Arg0: &mut UpgradeManager)

70ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

71Call package::version(&UpgradeCap): u64

72LdU64(1)

73Add

74Call fresh_proposal(u32, PackageDigest, u64): UpgradeProposal

75CopyLoc[10](loc5: &mut UpgradeProposal)

76WriteRef

77Branch(80)

B12:

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

79Pop

B13:

80MoveLoc[10](loc5: &mut UpgradeProposal)

81StLoc[6](loc1: &mut UpgradeProposal)

82Branch(102)

B14:

83CopyLoc[9](loc4: u32)

84CopyLoc[7](loc2: PackageDigest)

85CopyLoc[0](Arg0: &mut UpgradeManager)

86ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

87Call package::version(&UpgradeCap): u64

88LdU64(1)

89Add

90Call fresh_proposal(u32, PackageDigest, u64): UpgradeProposal

91StLoc[11](loc6: UpgradeProposal)

92CopyLoc[0](Arg0: &mut UpgradeManager)

93MutBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

94CopyLoc[7](loc2: PackageDigest)

95MoveLoc[11](loc6: UpgradeProposal)

96Call table::add<PackageDigest, UpgradeProposal>(&mut Table<PackageDigest, UpgradeProposal>, PackageDigest, UpgradeProposal)

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

98MutBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

99CopyLoc[7](loc2: PackageDigest)

100Call table::borrow_mut<PackageDigest, UpgradeProposal>(&mut Table<PackageDigest, UpgradeProposal>, PackageDigest): &mut UpgradeProposal

101StLoc[6](loc1: &mut UpgradeProposal)

B15:

102MoveLoc[6](loc1: &mut UpgradeProposal)

103StLoc[12](loc7: &mut UpgradeProposal)

104CopyLoc[12](loc7: &mut UpgradeProposal)

105MoveLoc[3](Arg3: ID)

106MoveLoc[13](loc8: u16)

107Call add_vote(&mut UpgradeProposal, ID, u16)

108MoveLoc[1](Arg1: &Staking)

109MoveLoc[12](loc7: &mut UpgradeProposal)

110ImmBorrowField[4](UpgradeProposal.voting_weight: u16)

111ReadRef

112Call staking::is_quorum(&Staking, u16): bool

113BrFalse(119)

B16:

114MoveLoc[9](loc4: u32)

115ImmBorrowLoc[7](loc2: PackageDigest)

116ImmBorrowField[5](PackageDigest.pos0: vector<u8>)

117ReadRef

118Call events::emit_contract_upgrade_quorum_reached(u32, vector<u8>)

B17:

119Ret

}

public authorize_upgrade(Arg0: &mut UpgradeManager, Arg1: &Staking, Arg2: vector<u8>): UpgradeTicket {

L3: loc0: PackageDigest

L4: loc1: vector<u8>

L5: loc2: u8

L6: loc3: UpgradeProposal

B0:

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

1StLoc[4](loc1: vector<u8>)

2ImmBorrowLoc[4](loc1: vector<u8>)

3VecLen(28)

4LdU64(32)

5Eq

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &Staking)

9Pop

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

11Pop

12LdConst[3](u64: 3)

13Abort

B3:

14MoveLoc[4](loc1: vector<u8>)

15Pack[0](PackageDigest)

16StLoc[3](loc0: PackageDigest)

17CopyLoc[0](Arg0: &mut UpgradeManager)

18ImmBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

19CopyLoc[3](loc0: PackageDigest)

20Call table::contains<PackageDigest, UpgradeProposal>(&Table<PackageDigest, UpgradeProposal>, PackageDigest): bool

21BrFalse(23)

B4:

22Branch(29)

B5:

23MoveLoc[1](Arg1: &Staking)

24Pop

25MoveLoc[0](Arg0: &mut UpgradeManager)

26Pop

27LdConst[4](u64: 4)

28Abort

B6:

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

30MutBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

31CopyLoc[3](loc0: PackageDigest)

32Call table::remove<PackageDigest, UpgradeProposal>(&mut Table<PackageDigest, UpgradeProposal>, PackageDigest): UpgradeProposal

33StLoc[6](loc3: UpgradeProposal)

34ImmBorrowLoc[6](loc3: UpgradeProposal)

35ImmBorrowField[1](UpgradeProposal.epoch: u32)

36ReadRef

37CopyLoc[1](Arg1: &Staking)

38Call staking::epoch(&Staking): u32

39Eq

40BrFalse(42)

B7:

41Branch(48)

B8:

42MoveLoc[1](Arg1: &Staking)

43Pop

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

45Pop

46LdConst[5](u64: 5)

47Abort

B9:

48MoveLoc[1](Arg1: &Staking)

49ImmBorrowLoc[6](loc3: UpgradeProposal)

50ImmBorrowField[4](UpgradeProposal.voting_weight: u16)

51ReadRef

52Call staking::is_quorum(&Staking, u16): bool

53BrFalse(55)

B10:

54Branch(59)

B11:

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

56Pop

57LdConst[6](u64: 6)

58Abort

B12:

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

60ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

61Call package::version(&UpgradeCap): u64

62LdU64(1)

63Add

64ImmBorrowLoc[6](loc3: UpgradeProposal)

65ImmBorrowField[2](UpgradeProposal.version: u64)

66ReadRef

67Eq

68BrFalse(70)

B13:

69Branch(74)

B14:

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

71Pop

72LdConst[7](u64: 7)

73Abort

B15:

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

75ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

76Call package::upgrade_policy(&UpgradeCap): u8

77StLoc[5](loc2: u8)

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

79MutBorrowField[3](UpgradeManager.cap: UpgradeCap)

80MoveLoc[5](loc2: u8)

81ImmBorrowLoc[3](loc0: PackageDigest)

82ImmBorrowField[5](PackageDigest.pos0: vector<u8>)

83ReadRef

84Call package::authorize_upgrade(&mut UpgradeCap, u8, vector<u8>): UpgradeTicket

85Ret

}

public authorize_emergency_upgrade(Arg0: &mut UpgradeManager, Arg1: &EmergencyUpgradeCap, Arg2: vector<u8>): UpgradeTicket {

L3: loc0: u8

B0:

0MoveLoc[1](Arg1: &EmergencyUpgradeCap)

1ImmBorrowField[6](EmergencyUpgradeCap.upgrade_manager_id: ID)

2ReadRef

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

4FreezeRef

5Call object::id<UpgradeManager>(&UpgradeManager): ID

6Eq

7BrFalse(9)

B1:

8Branch(13)

B2:

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

10Pop

11LdConst[0](u64: 0)

12Abort

B3:

13CopyLoc[0](Arg0: &mut UpgradeManager)

14ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

15Call package::upgrade_policy(&UpgradeCap): u8

16StLoc[3](loc0: u8)

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

18MutBorrowField[3](UpgradeManager.cap: UpgradeCap)

19MoveLoc[3](loc0: u8)

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

21Call package::authorize_upgrade(&mut UpgradeCap, u8, vector<u8>): UpgradeTicket

22Ret

}

public commit_upgrade(Arg0: &mut UpgradeManager, Arg1: &mut Staking, Arg2: &mut System, Arg3: UpgradeReceipt) {

L4: loc0: ID

B0:

0ImmBorrowLoc[3](Arg3: UpgradeReceipt)

1Call package::receipt_package(&UpgradeReceipt): ID

2StLoc[4](loc0: ID)

3MoveLoc[1](Arg1: &mut Staking)

4CopyLoc[4](loc0: ID)

5Call staking::set_new_package_id(&mut Staking, ID)

6MoveLoc[2](Arg2: &mut System)

7MoveLoc[4](loc0: ID)

8Call system::set_new_package_id(&mut System, ID)

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

10MutBorrowField[3](UpgradeManager.cap: UpgradeCap)

11MoveLoc[3](Arg3: UpgradeReceipt)

12Call package::commit_upgrade(&mut UpgradeCap, UpgradeReceipt)

13Ret

}

public cleanup_upgrade_proposals(Arg0: &mut UpgradeManager, Arg1: &Staking, Arg2: vector<vector<u8>>) {

L3: loc0: u64

L4: loc1: bool

L5: loc2: vector<u8>

L6: loc3: PackageDigest

L7: loc4: u64

L8: loc5: &UpgradeProposal

L9: loc6: u64

L10: loc7: vector<vector<u8>>

B0:

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

1StLoc[10](loc7: vector<vector<u8>>)

2MutBorrowLoc[10](loc7: vector<vector<u8>>)

3Call vector::reverse<vector<u8>>(&mut vector<vector<u8>>)

4ImmBorrowLoc[10](loc7: vector<vector<u8>>)

5VecLen(45)

6StLoc[3](loc0: u64)

7LdU64(0)

8StLoc[7](loc4: u64)

9MoveLoc[3](loc0: u64)

10StLoc[9](loc6: u64)

B1:

11CopyLoc[7](loc4: u64)

12CopyLoc[9](loc6: u64)

13Lt

14BrFalse(78)

B2:

15CopyLoc[7](loc4: u64)

16Pop

17MutBorrowLoc[10](loc7: vector<vector<u8>>)

18VecPopBack(45)

19StLoc[5](loc2: vector<u8>)

20ImmBorrowLoc[5](loc2: vector<u8>)

21VecLen(28)

22LdU64(32)

23Eq

24BrFalse(26)

B3:

25Branch(32)

B4:

26MoveLoc[1](Arg1: &Staking)

27Pop

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

29Pop

30LdConst[3](u64: 3)

31Abort

B5:

32MoveLoc[5](loc2: vector<u8>)

33Pack[0](PackageDigest)

34StLoc[6](loc3: PackageDigest)

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

36ImmBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

37CopyLoc[6](loc3: PackageDigest)

38Call table::contains<PackageDigest, UpgradeProposal>(&Table<PackageDigest, UpgradeProposal>, PackageDigest): bool

39BrFalse(73)

B6:

40CopyLoc[0](Arg0: &mut UpgradeManager)

41ImmBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

42CopyLoc[6](loc3: PackageDigest)

43Call table::borrow<PackageDigest, UpgradeProposal>(&Table<PackageDigest, UpgradeProposal>, PackageDigest): &UpgradeProposal

44StLoc[8](loc5: &UpgradeProposal)

45CopyLoc[8](loc5: &UpgradeProposal)

46ImmBorrowField[2](UpgradeProposal.version: u64)

47ReadRef

48CopyLoc[0](Arg0: &mut UpgradeManager)

49ImmBorrowField[3](UpgradeManager.cap: UpgradeCap)

50Call package::version(&UpgradeCap): u64

51Le

52BrFalse(59)

B7:

53Branch(54)

B8:

54MoveLoc[8](loc5: &UpgradeProposal)

55Pop

56LdTrue

57StLoc[4](loc1: bool)

58Branch(66)

B9:

59MoveLoc[8](loc5: &UpgradeProposal)

60ImmBorrowField[1](UpgradeProposal.epoch: u32)

61ReadRef

62CopyLoc[1](Arg1: &Staking)

63Call staking::epoch(&Staking): u32

64Lt

65StLoc[4](loc1: bool)

B10:

66MoveLoc[4](loc1: bool)

67BrFalse(73)

B11:

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

69MutBorrowField[0](UpgradeManager.upgrade_proposals: Table<PackageDigest, UpgradeProposal>)

70MoveLoc[6](loc3: PackageDigest)

71Call table::remove<PackageDigest, UpgradeProposal>(&mut Table<PackageDigest, UpgradeProposal>, PackageDigest): UpgradeProposal

72Pop

B12:

73MoveLoc[7](loc4: u64)

74LdU64(1)

75Add

76StLoc[7](loc4: u64)

77Branch(11)

B13:

78MoveLoc[1](Arg1: &Staking)

79Pop

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

81Pop

82MoveLoc[10](loc7: vector<vector<u8>>)

83VecUnpack(45, 0)

84Ret

}

public burn_emergency_upgrade_cap(Arg0: EmergencyUpgradeCap) {

B0:

0MoveLoc[0](Arg0: EmergencyUpgradeCap)

1Unpack[3](EmergencyUpgradeCap)

2Pop

3Call object::delete(UID)

4Ret

}

fresh_proposal(Arg0: u32, Arg1: PackageDigest, Arg2: u64): UpgradeProposal {

B0:

0CopyLoc[0](Arg0: u32)

1ImmBorrowLoc[1](Arg1: PackageDigest)

2ImmBorrowField[5](PackageDigest.pos0: vector<u8>)

3ReadRef

4Call events::emit_contract_upgrade_proposed(u32, vector<u8>)

5MoveLoc[0](Arg0: u32)

6MoveLoc[1](Arg1: PackageDigest)

7MoveLoc[2](Arg2: u64)

8LdU16(0)

9Call vec_set::empty<ID>(): VecSet<ID>

10Pack[1](UpgradeProposal)

11Ret

}

add_vote(Arg0: &mut UpgradeProposal, Arg1: ID, Arg2: u16) {

B0:

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

1ImmBorrowField[7](UpgradeProposal.voters: VecSet<ID>)

2ImmBorrowLoc[1](Arg1: ID)

3Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool

4Not

5BrFalse(7)

B1:

6Branch(11)

B2:

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

8Pop

9LdConst[2](u64: 2)

10Abort

B3:

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

12MutBorrowField[7](UpgradeProposal.voters: VecSet<ID>)

13MoveLoc[1](Arg1: ID)

14Call vec_set::insert<ID>(&mut VecSet<ID>, ID)

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

16ImmBorrowField[4](UpgradeProposal.voting_weight: u16)

17ReadRef

18MoveLoc[2](Arg2: u16)

19Add

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

21MutBorrowField[4](UpgradeProposal.voting_weight: u16)

22WriteRef

23Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

4 => u64: 4

5 => u64: 5

6 => u64: 6

7 => u64: 7

]

}