nft

Module0x7713…9f9d

Move path: 0xaec9…5faa::nft
Functions: 2212 public, 0 entry
Structs: 5
Friend modules: flash_loan router

nft

Bytecode1230 lines

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

// Move bytecode v6

module aec914fe1ed3be0aa3fc3cc610cccba02ace491ab45589035f657e1097c75faa.nft {

use aec914fe1ed3be0aa3fc3cc610cccba02ace491ab45589035f657e1097c75faa::admin;

use aec914fe1ed3be0aa3fc3cc610cccba02ace491ab45589035f657e1097c75faa::events;

use aec914fe1ed3be0aa3fc3cc610cccba02ace491ab45589035f657e1097c75faa::treasury;

use aec914fe1ed3be0aa3fc3cc610cccba02ace491ab45589035f657e1097c75faa::version;

use 0d801d9150facf2e763df8fc674a96253ea785adbae1c86deb03c98444bf4ef4::cro;

use c892551155735e7b7aa7ab4b9dc45908e985f0723289cb63277ea1ccaabb8fea::points;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::display;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::sui;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer_policy;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::types;

struct NFT has drop {

dummy_field: bool

}

struct NftConfig has store, key {

id: UID,

version: u64,

tge_time: u64,

unlock_time: u64,

end_lock_time: u64,

cro_per_points: u64,

total_mint_nfts: u64,

total_staked_points: u64,

user_to_nft: Table<address, ID>,

nft_to_user: Table<ID, address>,

nft_price: u64,

referral_nft_price: u64,

mint_reward: u64,

referral_mint_reward: u64,

points_per_lending: u64,

points_per_swap: u64

}

struct CroNft has store, key {

id: UID,

staked_points: Balance<POINTS>,

staked_cro: Balance<CRO>,

unlock_time: u64,

owner: address

}

struct MintNftEvent has copy, drop {

nft_id: address,

owner: address

}

struct MintReferralNftEvent has copy, drop {

nft_id: address,

owner: address,

referral: address

}

init(Arg0: NFT, Arg1: &mut TxContext) {

L2: loc0: Publisher

L3: loc1: Display<CroNft>

L4: loc2: TransferPolicyCap<CroNft>

B0:

0MoveLoc[0](Arg0: NFT)

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

2Call package::claim<NFT>(NFT, &mut TxContext): Publisher

3StLoc[2](loc0: Publisher)

4ImmBorrowLoc[2](loc0: Publisher)

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

6Call display::new<CroNft>(&Publisher, &mut TxContext): Display<CroNft>

7StLoc[3](loc1: Display<CroNft>)

8MutBorrowLoc[3](loc1: Display<CroNft>)

9LdConst[8](vector<u8>: "nam..)

10Call string::utf8(vector<u8>): String

11LdConst[9](vector<u8>: "Cro..)

12Call string::utf8(vector<u8>): String

13Call display::add<CroNft>(&mut Display<CroNft>, String, String)

14MutBorrowLoc[3](loc1: Display<CroNft>)

15LdConst[10](vector<u8>: "des..)

16Call string::utf8(vector<u8>): String

17LdConst[9](vector<u8>: "Cro..)

18Call string::utf8(vector<u8>): String

19Call display::add<CroNft>(&mut Display<CroNft>, String, String)

20MutBorrowLoc[3](loc1: Display<CroNft>)

21LdConst[11](vector<u8>: "ima..)

22Call string::utf8(vector<u8>): String

23LdConst[6](vector<u8>: "htt..)

24Call string::utf8(vector<u8>): String

25Call display::add<CroNft>(&mut Display<CroNft>, String, String)

26MutBorrowLoc[3](loc1: Display<CroNft>)

27LdConst[12](vector<u8>: "min..)

28Call string::utf8(vector<u8>): String

29LdConst[13](vector<u8>: "{mi..)

30Call string::utf8(vector<u8>): String

31Call display::add<CroNft>(&mut Display<CroNft>, String, String)

32MutBorrowLoc[3](loc1: Display<CroNft>)

33Call display::update_version<CroNft>(&mut Display<CroNft>)

34ImmBorrowLoc[2](loc0: Publisher)

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

36Call transfer_policy::new<CroNft>(&Publisher, &mut TxContext): TransferPolicy<CroNft> * TransferPolicyCap<CroNft>

37StLoc[4](loc2: TransferPolicyCap<CroNft>)

38Call transfer::public_share_object<TransferPolicy<CroNft>>(TransferPolicy<CroNft>)

39MoveLoc[4](loc2: TransferPolicyCap<CroNft>)

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

41FreezeRef

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

43Call transfer::public_transfer<TransferPolicyCap<CroNft>>(TransferPolicyCap<CroNft>, address)

44MoveLoc[2](loc0: Publisher)

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

46FreezeRef

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

48Call transfer::public_transfer<Publisher>(Publisher, address)

49MoveLoc[3](loc1: Display<CroNft>)

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

51FreezeRef

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

53Call transfer::public_transfer<Display<CroNft>>(Display<CroNft>, address)

54Ret

}

public get_points_per_lending(Arg0: &NftConfig): u64 {

B0:

0MoveLoc[0](Arg0: &NftConfig)

1ImmBorrowField[0](NftConfig.points_per_lending: u64)

2ReadRef

3Ret

}

public get_points_per_swap(Arg0: &NftConfig): u64 {

B0:

0MoveLoc[0](Arg0: &NftConfig)

1ImmBorrowField[1](NftConfig.points_per_swap: u64)

2ReadRef

3Ret

}

check_version(Arg0: &NftConfig) {

B0:

0MoveLoc[0](Arg0: &NftConfig)

1ImmBorrowField[2](NftConfig.version: u64)

2ReadRef

3Call version::check_version(u64)

4Ret

}

public(friend) check_before_tge(Arg0: &NftConfig, Arg1: &Clock): bool {

L2: loc0: bool

L3: loc1: bool

B0:

0CopyLoc[0](Arg0: &NftConfig)

1ImmBorrowField[3](NftConfig.tge_time: u64)

2ReadRef

3LdU64(0)

4Eq

5BrFalse(13)

B1:

6MoveLoc[0](Arg0: &NftConfig)

7Pop

8MoveLoc[1](Arg1: &Clock)

9Pop

10LdTrue

11StLoc[2](loc0: bool)

12Branch(20)

B2:

13MoveLoc[1](Arg1: &Clock)

14Call clock::timestamp_ms(&Clock): u64

15MoveLoc[0](Arg0: &NftConfig)

16ImmBorrowField[3](NftConfig.tge_time: u64)

17ReadRef

18Lt

19StLoc[2](loc0: bool)

B3:

20MoveLoc[2](loc0: bool)

21BrFalse(25)

B4:

22LdTrue

23StLoc[3](loc1: bool)

24Branch(27)

B5:

25LdFalse

26StLoc[3](loc1: bool)

B6:

27MoveLoc[3](loc1: bool)

28Ret

}

public change_nft_config(Arg0: &AdminCap, Arg1: &mut NftConfig, Arg2: &mut Option<u64>, Arg3: &mut Option<u64>, Arg4: &mut Option<u64>, Arg5: &mut Option<u64>, Arg6: &mut Option<u64>, Arg7: &mut Option<u64>, Arg8: &mut Option<u64>, Arg9: &mut Option<u64>, Arg10: &mut Option<u64>, Arg11: &mut Option<u64>, Arg12: &mut Option<u64>) {

B0:

0CopyLoc[2](Arg2: &mut Option<u64>)

1FreezeRef

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

3BrFalse(10)

B1:

4MoveLoc[2](Arg2: &mut Option<u64>)

5Call option::extract<u64>(&mut Option<u64>): u64

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

7MutBorrowField[2](NftConfig.version: u64)

8WriteRef

9Branch(12)

B2:

10MoveLoc[2](Arg2: &mut Option<u64>)

11Pop

B3:

12CopyLoc[3](Arg3: &mut Option<u64>)

13FreezeRef

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

15BrFalse(22)

B4:

16MoveLoc[3](Arg3: &mut Option<u64>)

17Call option::extract<u64>(&mut Option<u64>): u64

18CopyLoc[1](Arg1: &mut NftConfig)

19MutBorrowField[3](NftConfig.tge_time: u64)

20WriteRef

21Branch(24)

B5:

22MoveLoc[3](Arg3: &mut Option<u64>)

23Pop

B6:

24CopyLoc[5](Arg5: &mut Option<u64>)

25FreezeRef

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

27BrFalse(34)

B7:

28MoveLoc[5](Arg5: &mut Option<u64>)

29Call option::extract<u64>(&mut Option<u64>): u64

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

31MutBorrowField[4](NftConfig.end_lock_time: u64)

32WriteRef

33Branch(36)

B8:

34MoveLoc[5](Arg5: &mut Option<u64>)

35Pop

B9:

36CopyLoc[4](Arg4: &mut Option<u64>)

37FreezeRef

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

39BrFalse(46)

B10:

40MoveLoc[4](Arg4: &mut Option<u64>)

41Call option::extract<u64>(&mut Option<u64>): u64

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

43MutBorrowField[5](NftConfig.unlock_time: u64)

44WriteRef

45Branch(48)

B11:

46MoveLoc[4](Arg4: &mut Option<u64>)

47Pop

B12:

48CopyLoc[6](Arg6: &mut Option<u64>)

49FreezeRef

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

51BrFalse(58)

B13:

52MoveLoc[6](Arg6: &mut Option<u64>)

53Call option::extract<u64>(&mut Option<u64>): u64

54CopyLoc[1](Arg1: &mut NftConfig)

55MutBorrowField[6](NftConfig.cro_per_points: u64)

56WriteRef

57Branch(60)

B14:

58MoveLoc[6](Arg6: &mut Option<u64>)

59Pop

B15:

60CopyLoc[7](Arg7: &mut Option<u64>)

61FreezeRef

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

63BrFalse(70)

B16:

64MoveLoc[7](Arg7: &mut Option<u64>)

65Call option::extract<u64>(&mut Option<u64>): u64

66CopyLoc[1](Arg1: &mut NftConfig)

67MutBorrowField[7](NftConfig.nft_price: u64)

68WriteRef

69Branch(72)

B17:

70MoveLoc[7](Arg7: &mut Option<u64>)

71Pop

B18:

72CopyLoc[8](Arg8: &mut Option<u64>)

73FreezeRef

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

75BrFalse(82)

B19:

76MoveLoc[8](Arg8: &mut Option<u64>)

77Call option::extract<u64>(&mut Option<u64>): u64

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

79MutBorrowField[8](NftConfig.referral_nft_price: u64)

80WriteRef

81Branch(84)

B20:

82MoveLoc[8](Arg8: &mut Option<u64>)

83Pop

B21:

84CopyLoc[9](Arg9: &mut Option<u64>)

85FreezeRef

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

87BrFalse(94)

B22:

88MoveLoc[9](Arg9: &mut Option<u64>)

89Call option::extract<u64>(&mut Option<u64>): u64

90CopyLoc[1](Arg1: &mut NftConfig)

91MutBorrowField[9](NftConfig.mint_reward: u64)

92WriteRef

93Branch(96)

B23:

94MoveLoc[9](Arg9: &mut Option<u64>)

95Pop

B24:

96CopyLoc[10](Arg10: &mut Option<u64>)

97FreezeRef

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

99BrFalse(106)

B25:

100MoveLoc[10](Arg10: &mut Option<u64>)

101Call option::extract<u64>(&mut Option<u64>): u64

102CopyLoc[1](Arg1: &mut NftConfig)

103MutBorrowField[10](NftConfig.referral_mint_reward: u64)

104WriteRef

105Branch(108)

B26:

106MoveLoc[10](Arg10: &mut Option<u64>)

107Pop

B27:

108CopyLoc[11](Arg11: &mut Option<u64>)

109FreezeRef

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

111BrFalse(118)

B28:

112MoveLoc[11](Arg11: &mut Option<u64>)

113Call option::extract<u64>(&mut Option<u64>): u64

114CopyLoc[1](Arg1: &mut NftConfig)

115MutBorrowField[0](NftConfig.points_per_lending: u64)

116WriteRef

117Branch(120)

B29:

118MoveLoc[11](Arg11: &mut Option<u64>)

119Pop

B30:

120CopyLoc[12](Arg12: &mut Option<u64>)

121FreezeRef

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

123BrFalse(130)

B31:

124MoveLoc[12](Arg12: &mut Option<u64>)

125Call option::extract<u64>(&mut Option<u64>): u64

126MoveLoc[1](Arg1: &mut NftConfig)

127MutBorrowField[1](NftConfig.points_per_swap: u64)

128WriteRef

129Branch(134)

B32:

130MoveLoc[12](Arg12: &mut Option<u64>)

131Pop

132MoveLoc[1](Arg1: &mut NftConfig)

133Pop

B33:

134Ret

}

public(friend) create_config<Ty0: drop>(Arg0: &Ty0, Arg1: &mut TxContext): NftConfig {

B0:

0MoveLoc[0](Arg0: &Ty0)

1Call types::is_one_time_witness<Ty0>(&Ty0): bool

2BrFalse(4)

B1:

3Branch(8)

B2:

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

5Pop

6LdU64(1)

7Abort

B3:

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

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

10Call version::current_version(): u64

11LdConst[0](u64: 1903..)

12LdConst[0](u64: 1903..)

13LdConst[1](u64: 1966..)

14LdConst[3](u64: 0)

15LdU64(0)

16LdU64(0)

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

18Call table::new<address, ID>(&mut TxContext): Table<address, ID>

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

20Call table::new<ID, address>(&mut TxContext): Table<ID, address>

21LdConst[3](u64: 0)

22LdConst[3](u64: 0)

23LdConst[4](u64: 50)

24LdConst[4](u64: 50)

25LdConst[4](u64: 50)

26LdConst[4](u64: 50)

27Pack[1](NftConfig)

28Ret

}

public mint_nft(Arg0: &mut NftConfig, Arg1: &mut Treasury, Arg2: Coin<SUI>, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: CroNft

L6: loc1: address

B0:

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

1FreezeRef

2Call check_version(&NftConfig)

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

4FreezeRef

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

6StLoc[6](loc1: address)

7ImmBorrowLoc[2](Arg2: Coin<SUI>)

8Call coin::value<SUI>(&Coin<SUI>): u64

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

10ImmBorrowField[7](NftConfig.nft_price: u64)

11ReadRef

12Eq

13BrFalse(15)

B1:

14Branch(25)

B2:

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

16Pop

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

18Pop

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

20Pop

21MoveLoc[3](Arg3: &Clock)

22Pop

23LdU64(0)

24Abort

B3:

25LdU64(1)

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

27ImmBorrowField[11](NftConfig.total_mint_nfts: u64)

28ReadRef

29Add

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

31MutBorrowField[11](NftConfig.total_mint_nfts: u64)

32WriteRef

33CopyLoc[1](Arg1: &mut Treasury)

34MoveLoc[2](Arg2: Coin<SUI>)

35Call treasury::deposit<SUI>(&mut Treasury, Coin<SUI>)

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

37FreezeRef

38MoveLoc[1](Arg1: &mut Treasury)

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

40ImmBorrowField[9](NftConfig.mint_reward: u64)

41ReadRef

42MoveLoc[3](Arg3: &Clock)

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

44Call zero_obj_mint_with_points(&NftConfig, &mut Treasury, u64, &Clock, &mut TxContext)

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

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

47Call balance::zero<POINTS>(): Balance<POINTS>

48Call balance::zero<CRO>(): Balance<CRO>

49LdU64(0)

50CopyLoc[6](loc1: address)

51Pack[2](CroNft)

52StLoc[5](loc0: CroNft)

53ImmBorrowLoc[5](loc0: CroNft)

54ImmBorrowField[12](CroNft.id: UID)

55Call object::uid_to_address(&UID): address

56ImmBorrowLoc[5](loc0: CroNft)

57ImmBorrowField[13](CroNft.owner: address)

58ReadRef

59Pack[3](MintNftEvent)

60Call event::emit<MintNftEvent>(MintNftEvent)

61MoveLoc[0](Arg0: &mut NftConfig)

62ImmBorrowLoc[5](loc0: CroNft)

63CopyLoc[6](loc1: address)

64Call register(&mut NftConfig, &CroNft, address)

65MoveLoc[5](loc0: CroNft)

66MoveLoc[6](loc1: address)

67Call transfer::public_transfer<CroNft>(CroNft, address)

68Ret

}

public referral_mint(Arg0: &mut NftConfig, Arg1: &mut Treasury, Arg2: Coin<SUI>, Arg3: address, Arg4: &Clock, Arg5: &mut TxContext) {

L6: loc0: CroNft

L7: loc1: address

B0:

0CopyLoc[5](Arg5: &mut TxContext)

1FreezeRef

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

3StLoc[7](loc1: address)

4CopyLoc[3](Arg3: address)

5CopyLoc[7](loc1: address)

6Neq

7BrFalse(9)

B1:

8Branch(19)

B2:

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

10Pop

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

12Pop

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

14Pop

15MoveLoc[4](Arg4: &Clock)

16Pop

17LdU64(0)

18Abort

B3:

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

20FreezeRef

21Call check_version(&NftConfig)

22ImmBorrowLoc[2](Arg2: Coin<SUI>)

23Call coin::value<SUI>(&Coin<SUI>): u64

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

25ImmBorrowField[8](NftConfig.referral_nft_price: u64)

26ReadRef

27Eq

28BrFalse(30)

B4:

29Branch(40)

B5:

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

31Pop

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

33Pop

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

35Pop

36MoveLoc[4](Arg4: &Clock)

37Pop

38LdU64(0)

39Abort

B6:

40LdU64(1)

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

42ImmBorrowField[11](NftConfig.total_mint_nfts: u64)

43ReadRef

44Add

45CopyLoc[0](Arg0: &mut NftConfig)

46MutBorrowField[11](NftConfig.total_mint_nfts: u64)

47WriteRef

48CopyLoc[1](Arg1: &mut Treasury)

49MoveLoc[2](Arg2: Coin<SUI>)

50Call treasury::deposit<SUI>(&mut Treasury, Coin<SUI>)

51CopyLoc[0](Arg0: &mut NftConfig)

52FreezeRef

53CopyLoc[1](Arg1: &mut Treasury)

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

55ImmBorrowField[9](NftConfig.mint_reward: u64)

56ReadRef

57CopyLoc[4](Arg4: &Clock)

58CopyLoc[5](Arg5: &mut TxContext)

59Call zero_obj_mint_with_points(&NftConfig, &mut Treasury, u64, &Clock, &mut TxContext)

60CopyLoc[5](Arg5: &mut TxContext)

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

62Call balance::zero<POINTS>(): Balance<POINTS>

63Call balance::zero<CRO>(): Balance<CRO>

64LdU64(0)

65CopyLoc[7](loc1: address)

66Pack[2](CroNft)

67StLoc[6](loc0: CroNft)

68ImmBorrowLoc[6](loc0: CroNft)

69ImmBorrowField[12](CroNft.id: UID)

70Call object::uid_to_address(&UID): address

71ImmBorrowLoc[6](loc0: CroNft)

72ImmBorrowField[13](CroNft.owner: address)

73ReadRef

74CopyLoc[3](Arg3: address)

75Pack[4](MintReferralNftEvent)

76Call event::emit<MintReferralNftEvent>(MintReferralNftEvent)

77CopyLoc[0](Arg0: &mut NftConfig)

78ImmBorrowLoc[6](loc0: CroNft)

79CopyLoc[7](loc1: address)

80Call register(&mut NftConfig, &CroNft, address)

81MoveLoc[6](loc0: CroNft)

82MoveLoc[7](loc1: address)

83Call transfer::public_transfer<CroNft>(CroNft, address)

84CopyLoc[0](Arg0: &mut NftConfig)

85FreezeRef

86MoveLoc[4](Arg4: &Clock)

87Call check_before_tge(&NftConfig, &Clock): bool

88BrFalse(100)

B7:

89MoveLoc[1](Arg1: &mut Treasury)

90Call treasury::borrow_from_treasury<POINTS>(&mut Treasury): &mut Balance<POINTS>

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

92ImmBorrowField[10](NftConfig.referral_mint_reward: u64)

93ReadRef

94Call balance::split<POINTS>(&mut Balance<POINTS>, u64): Balance<POINTS>

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

96Call coin::from_balance<POINTS>(Balance<POINTS>, &mut TxContext): Coin<POINTS>

97MoveLoc[3](Arg3: address)

98Call transfer::public_transfer<Coin<POINTS>>(Coin<POINTS>, address)

99Branch(106)

B8:

100MoveLoc[1](Arg1: &mut Treasury)

101Pop

102MoveLoc[0](Arg0: &mut NftConfig)

103Pop

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

105Pop

B9:

106Ret

}

public(friend) register(Arg0: &mut NftConfig, Arg1: &CroNft, Arg2: address) {

L3: loc0: ID

B0:

0MoveLoc[1](Arg1: &CroNft)

1Call object::id<CroNft>(&CroNft): ID

2StLoc[3](loc0: ID)

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

4ImmBorrowField[14](NftConfig.user_to_nft: Table<address, ID>)

5CopyLoc[2](Arg2: address)

6Call table::contains<address, ID>(&Table<address, ID>, address): bool

7Not

8BrFalse(10)

B1:

9Branch(14)

B2:

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

11Pop

12LdU64(3)

13Abort

B3:

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

15ImmBorrowField[15](NftConfig.nft_to_user: Table<ID, address>)

16CopyLoc[3](loc0: ID)

17Call table::contains<ID, address>(&Table<ID, address>, ID): bool

18Not

19BrFalse(21)

B4:

20Branch(25)

B5:

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

22Pop

23LdU64(2)

24Abort

B6:

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

26MutBorrowField[14](NftConfig.user_to_nft: Table<address, ID>)

27CopyLoc[2](Arg2: address)

28CopyLoc[3](loc0: ID)

29Call table::add<address, ID>(&mut Table<address, ID>, address, ID)

30MoveLoc[0](Arg0: &mut NftConfig)

31MutBorrowField[15](NftConfig.nft_to_user: Table<ID, address>)

32MoveLoc[3](loc0: ID)

33MoveLoc[2](Arg2: address)

34Call table::add<ID, address>(&mut Table<ID, address>, ID, address)

35Ret

}

public add_points(Arg0: &mut NftConfig, Arg1: &mut CroNft, Arg2: Coin<POINTS>, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: u64

B0:

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

1FreezeRef

2MoveLoc[3](Arg3: &Clock)

3Call check_before_tge(&NftConfig, &Clock): bool

4BrFalse(6)

B1:

5Branch(14)

B2:

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

7Pop

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

9Pop

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

11Pop

12LdU64(1)

13Abort

B3:

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

15FreezeRef

16Call check_version(&NftConfig)

17ImmBorrowLoc[2](Arg2: Coin<POINTS>)

18Call coin::value<POINTS>(&Coin<POINTS>): u64

19StLoc[5](loc0: u64)

20CopyLoc[5](loc0: u64)

21CopyLoc[0](Arg0: &mut NftConfig)

22ImmBorrowField[16](NftConfig.total_staked_points: u64)

23ReadRef

24Add

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

26MutBorrowField[16](NftConfig.total_staked_points: u64)

27WriteRef

28MoveLoc[5](loc0: u64)

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

30FreezeRef

31Call events::emit_add_points_event(u64, &TxContext)

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

33MutBorrowField[17](CroNft.staked_points: Balance<POINTS>)

34MoveLoc[2](Arg2: Coin<POINTS>)

35Call coin::into_balance<POINTS>(Coin<POINTS>): Balance<POINTS>

36Call balance::join<POINTS>(&mut Balance<POINTS>, Balance<POINTS>): u64

37Pop

38Ret

}

public remove_points(Arg0: &mut NftConfig, Arg1: &mut CroNft, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext): Coin<POINTS> {

L5: loc0: Balance<POINTS>

B0:

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

1FreezeRef

2MoveLoc[3](Arg3: &Clock)

3Call check_before_tge(&NftConfig, &Clock): bool

4BrFalse(6)

B1:

5Branch(14)

B2:

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

7Pop

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

9Pop

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

11Pop

12LdU64(1)

13Abort

B3:

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

15FreezeRef

16Call check_version(&NftConfig)

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

18ImmBorrowField[16](NftConfig.total_staked_points: u64)

19ReadRef

20CopyLoc[2](Arg2: u64)

21Sub

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

23MutBorrowField[16](NftConfig.total_staked_points: u64)

24WriteRef

25MoveLoc[1](Arg1: &mut CroNft)

26MutBorrowField[17](CroNft.staked_points: Balance<POINTS>)

27CopyLoc[2](Arg2: u64)

28Call balance::split<POINTS>(&mut Balance<POINTS>, u64): Balance<POINTS>

29StLoc[5](loc0: Balance<POINTS>)

30MoveLoc[2](Arg2: u64)

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

32FreezeRef

33Call events::emit_remove_points_event(u64, &TxContext)

34MoveLoc[5](loc0: Balance<POINTS>)

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

36Call coin::from_balance<POINTS>(Balance<POINTS>, &mut TxContext): Coin<POINTS>

37Ret

}

public(friend) check_unlock_time_not_zero(Arg0: &CroNft) {

B0:

0MoveLoc[0](Arg0: &CroNft)

1ImmBorrowField[18](CroNft.unlock_time: u64)

2ReadRef

3LdU64(0)

4Neq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdU64(0)

8Abort

B3:

9Ret

}

public(friend) check_unlock_time_zero(Arg0: &CroNft) {

B0:

0MoveLoc[0](Arg0: &CroNft)

1ImmBorrowField[18](CroNft.unlock_time: u64)

2ReadRef

3LdU64(0)

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdU64(0)

8Abort

B3:

9Ret

}

public(friend) check_unlock_time_valid(Arg0: &CroNft, Arg1: &Clock) {

B0:

0MoveLoc[0](Arg0: &CroNft)

1ImmBorrowField[18](CroNft.unlock_time: u64)

2ReadRef

3MoveLoc[1](Arg1: &Clock)

4Call clock::timestamp_ms(&Clock): u64

5Le

6BrFalse(8)

B1:

7Branch(10)

B2:

8LdU64(1)

9Abort

B3:

10Ret

}

public(friend) update_prev_unlock_time(Arg0: &mut CroNft, Arg1: &Clock) {

B0:

0MoveLoc[1](Arg1: &Clock)

1Call clock::timestamp_ms(&Clock): u64

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

3MutBorrowField[18](CroNft.unlock_time: u64)

4WriteRef

5Ret

}

public(friend) update_unlock_time_init(Arg0: &mut CroNft) {

B0:

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

1FreezeRef

2Call check_unlock_time_zero(&CroNft)

3LdConst[0](u64: 1903..)

4MoveLoc[0](Arg0: &mut CroNft)

5MutBorrowField[18](CroNft.unlock_time: u64)

6WriteRef

7Ret

}

public claim_init(Arg0: &NftConfig, Arg1: &mut Treasury, Arg2: &mut CroNft, Arg3: &Clock) {

L4: loc0: Balance<CRO>

B0:

0CopyLoc[0](Arg0: &NftConfig)

1ImmBorrowField[3](NftConfig.tge_time: u64)

2ReadRef

3LdU64(0)

4Neq

5BrFalse(7)

B1:

6Branch(17)

B2:

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

8Pop

9MoveLoc[0](Arg0: &NftConfig)

10Pop

11MoveLoc[2](Arg2: &mut CroNft)

12Pop

13MoveLoc[3](Arg3: &Clock)

14Pop

15LdU64(0)

16Abort

B3:

17MoveLoc[3](Arg3: &Clock)

18Call clock::timestamp_ms(&Clock): u64

19CopyLoc[0](Arg0: &NftConfig)

20ImmBorrowField[3](NftConfig.tge_time: u64)

21ReadRef

22Ge

23BrFalse(25)

B4:

24Branch(33)

B5:

25MoveLoc[1](Arg1: &mut Treasury)

26Pop

27MoveLoc[0](Arg0: &NftConfig)

28Pop

29MoveLoc[2](Arg2: &mut CroNft)

30Pop

31LdU64(1)

32Abort

B6:

33CopyLoc[2](Arg2: &mut CroNft)

34Call update_unlock_time_init(&mut CroNft)

35MoveLoc[1](Arg1: &mut Treasury)

36Call treasury::borrow_from_treasury<CRO>(&mut Treasury): &mut Balance<CRO>

37CopyLoc[2](Arg2: &mut CroNft)

38ImmBorrowField[17](CroNft.staked_points: Balance<POINTS>)

39Call balance::value<POINTS>(&Balance<POINTS>): u64

40MoveLoc[0](Arg0: &NftConfig)

41ImmBorrowField[6](NftConfig.cro_per_points: u64)

42ReadRef

43Mul

44Call balance::split<CRO>(&mut Balance<CRO>, u64): Balance<CRO>

45StLoc[4](loc0: Balance<CRO>)

46MoveLoc[2](Arg2: &mut CroNft)

47MutBorrowField[19](CroNft.staked_cro: Balance<CRO>)

48MoveLoc[4](loc0: Balance<CRO>)

49Call balance::join<CRO>(&mut Balance<CRO>, Balance<CRO>): u64

50Pop

51Ret

}

public claim_cro(Arg0: &NftConfig, Arg1: &mut CroNft, Arg2: &Clock, Arg3: &mut TxContext): Coin<CRO> {

L4: loc0: Coin<CRO>

L5: loc1: u64

L6: loc2: u64

L7: loc3: Balance<CRO>

L8: loc4: Balance<CRO>

B0:

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

1ImmBorrowField[19](CroNft.staked_cro: Balance<CRO>)

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

3LdU64(0)

4Gt

5BrFalse(7)

B1:

6Branch(17)

B2:

7MoveLoc[0](Arg0: &NftConfig)

8Pop

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

10Pop

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

12Pop

13MoveLoc[2](Arg2: &Clock)

14Pop

15LdU64(0)

16Abort

B3:

17CopyLoc[0](Arg0: &NftConfig)

18ImmBorrowField[3](NftConfig.tge_time: u64)

19ReadRef

20LdU64(0)

21Neq

22BrFalse(24)

B4:

23Branch(34)

B5:

24MoveLoc[0](Arg0: &NftConfig)

25Pop

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

27Pop

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

29Pop

30MoveLoc[2](Arg2: &Clock)

31Pop

32LdU64(0)

33Abort

B6:

34CopyLoc[2](Arg2: &Clock)

35Call clock::timestamp_ms(&Clock): u64

36CopyLoc[0](Arg0: &NftConfig)

37ImmBorrowField[3](NftConfig.tge_time: u64)

38ReadRef

39Ge

40BrFalse(42)

B7:

41Branch(52)

B8:

42MoveLoc[0](Arg0: &NftConfig)

43Pop

44MoveLoc[1](Arg1: &mut CroNft)

45Pop

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

47Pop

48MoveLoc[2](Arg2: &Clock)

49Pop

50LdU64(1)

51Abort

B9:

52CopyLoc[2](Arg2: &Clock)

53Call clock::timestamp_ms(&Clock): u64

54CopyLoc[0](Arg0: &NftConfig)

55ImmBorrowField[5](NftConfig.unlock_time: u64)

56ReadRef

57Ge

58BrFalse(60)

B10:

59Branch(70)

B11:

60MoveLoc[0](Arg0: &NftConfig)

61Pop

62MoveLoc[1](Arg1: &mut CroNft)

63Pop

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

65Pop

66MoveLoc[2](Arg2: &Clock)

67Pop

68LdU64(2)

69Abort

B12:

70CopyLoc[2](Arg2: &Clock)

71Call clock::timestamp_ms(&Clock): u64

72CopyLoc[0](Arg0: &NftConfig)

73ImmBorrowField[4](NftConfig.end_lock_time: u64)

74ReadRef

75Ge

76BrFalse(110)

B13:

77MoveLoc[0](Arg0: &NftConfig)

78Pop

79MoveLoc[2](Arg2: &Clock)

80Pop

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

82ImmBorrowField[19](CroNft.staked_cro: Balance<CRO>)

83Call balance::value<CRO>(&Balance<CRO>): u64

84StLoc[5](loc1: u64)

85CopyLoc[5](loc1: u64)

86LdU64(0)

87Gt

88BrFalse(90)

B14:

89Branch(96)

B15:

90MoveLoc[1](Arg1: &mut CroNft)

91Pop

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

93Pop

94LdU64(0)

95Abort

B16:

96MoveLoc[1](Arg1: &mut CroNft)

97MutBorrowField[19](CroNft.staked_cro: Balance<CRO>)

98CopyLoc[5](loc1: u64)

99Call balance::split<CRO>(&mut Balance<CRO>, u64): Balance<CRO>

100StLoc[7](loc3: Balance<CRO>)

101MoveLoc[5](loc1: u64)

102CopyLoc[3](Arg3: &mut TxContext)

103FreezeRef

104Call events::emit_claim_cro_event(u64, &TxContext)

105MoveLoc[7](loc3: Balance<CRO>)

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

107Call coin::from_balance<CRO>(Balance<CRO>, &mut TxContext): Coin<CRO>

108StLoc[4](loc0: Coin<CRO>)

109Branch(165)

B17:

110CopyLoc[1](Arg1: &mut CroNft)

111FreezeRef

112Call check_unlock_time_not_zero(&CroNft)

113CopyLoc[1](Arg1: &mut CroNft)

114FreezeRef

115CopyLoc[2](Arg2: &Clock)

116Call check_unlock_time_valid(&CroNft, &Clock)

117CopyLoc[2](Arg2: &Clock)

118Call clock::timestamp_ms(&Clock): u64

119CopyLoc[1](Arg1: &mut CroNft)

120ImmBorrowField[18](CroNft.unlock_time: u64)

121ReadRef

122Sub

123CopyLoc[1](Arg1: &mut CroNft)

124ImmBorrowField[19](CroNft.staked_cro: Balance<CRO>)

125Call balance::value<CRO>(&Balance<CRO>): u64

126Mul

127CopyLoc[0](Arg0: &NftConfig)

128ImmBorrowField[4](NftConfig.end_lock_time: u64)

129ReadRef

130MoveLoc[0](Arg0: &NftConfig)

131ImmBorrowField[5](NftConfig.unlock_time: u64)

132ReadRef

133Sub

134Div

135StLoc[6](loc2: u64)

136CopyLoc[6](loc2: u64)

137LdU64(0)

138Gt

139BrFalse(141)

B18:

140Branch(149)

B19:

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

142Pop

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

144Pop

145MoveLoc[2](Arg2: &Clock)

146Pop

147LdU64(0)

148Abort

B20:

149CopyLoc[1](Arg1: &mut CroNft)

150MutBorrowField[19](CroNft.staked_cro: Balance<CRO>)

151CopyLoc[6](loc2: u64)

152Call balance::split<CRO>(&mut Balance<CRO>, u64): Balance<CRO>

153StLoc[8](loc4: Balance<CRO>)

154MoveLoc[1](Arg1: &mut CroNft)

155MoveLoc[2](Arg2: &Clock)

156Call update_prev_unlock_time(&mut CroNft, &Clock)

157MoveLoc[6](loc2: u64)

158CopyLoc[3](Arg3: &mut TxContext)

159FreezeRef

160Call events::emit_claim_cro_event(u64, &TxContext)

161MoveLoc[8](loc4: Balance<CRO>)

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

163Call coin::from_balance<CRO>(Balance<CRO>, &mut TxContext): Coin<CRO>

164StLoc[4](loc0: Coin<CRO>)

B21:

165MoveLoc[4](loc0: Coin<CRO>)

166Ret

}

public get_points_per_obj(): u64 {

B0:

0LdU64(2)

1Ret

}

public zero_obj_mint_with_points(Arg0: &NftConfig, Arg1: &mut Treasury, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: address

B0:

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

1FreezeRef

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

3StLoc[5](loc0: address)

4CopyLoc[2](Arg2: u64)

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

6Call zero_obj_mint_with_no_points(u64, &mut TxContext)

7MoveLoc[0](Arg0: &NftConfig)

8MoveLoc[3](Arg3: &Clock)

9Call check_before_tge(&NftConfig, &Clock): bool

10BrFalse(22)

B1:

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

12Call treasury::borrow_from_treasury<POINTS>(&mut Treasury): &mut Balance<POINTS>

13Call get_points_per_obj(): u64

14MoveLoc[2](Arg2: u64)

15Mul

16Call balance::split<POINTS>(&mut Balance<POINTS>, u64): Balance<POINTS>

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

18Call coin::from_balance<POINTS>(Balance<POINTS>, &mut TxContext): Coin<POINTS>

19MoveLoc[5](loc0: address)

20Call transfer::public_transfer<Coin<POINTS>>(Coin<POINTS>, address)

21Branch(26)

B2:

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

23Pop

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

25Pop

B3:

26Ret

}

public zero_obj_mint_with_no_points(Arg0: u64, Arg1: &mut TxContext) {

L2: loc0: u64

B0:

0CopyLoc[0](Arg0: u64)

1LdU64(0)

2Gt

3BrFalse(5)

B1:

4Branch(9)

B2:

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

6Pop

7LdU64(0)

8Abort

B3:

9LdU64(0)

10StLoc[2](loc0: u64)

B4:

11CopyLoc[2](loc0: u64)

12CopyLoc[0](Arg0: u64)

13Lt

14BrFalse(24)

B5:

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

16Call coin::zero<POINTS>(&mut TxContext): Coin<POINTS>

17LdConst[7](address: 0x00..)

18Call transfer::public_transfer<Coin<POINTS>>(Coin<POINTS>, address)

19MoveLoc[2](loc0: u64)

20LdU64(1)

21Add

22StLoc[2](loc0: u64)

23Branch(11)

B6:

24MoveLoc[0](Arg0: u64)

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

26FreezeRef

27Call events::emit_multi_zero_object_event(u64, &TxContext)

28Ret

}

public zero_obj_mint<Ty0>(Arg0: &NftConfig, Arg1: &mut Treasury, Arg2: Coin<Ty0>, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: address

B0:

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

1FreezeRef

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

3StLoc[5](loc0: address)

4ImmBorrowLoc[2](Arg2: Coin<Ty0>)

5Call coin::value<Ty0>(&Coin<Ty0>): u64

6LdU64(0)

7Eq

8BrFalse(10)

B1:

9Branch(20)

B2:

10MoveLoc[1](Arg1: &mut Treasury)

11Pop

12MoveLoc[0](Arg0: &NftConfig)

13Pop

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

15Pop

16MoveLoc[3](Arg3: &Clock)

17Pop

18LdU64(0)

19Abort

B3:

20MoveLoc[2](Arg2: Coin<Ty0>)

21LdConst[7](address: 0x00..)

22Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)

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

24FreezeRef

25Call events::emit_zero_object_event(&TxContext)

26MoveLoc[0](Arg0: &NftConfig)

27MoveLoc[3](Arg3: &Clock)

28Call check_before_tge(&NftConfig, &Clock): bool

29BrFalse(39)

B4:

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

31Call treasury::borrow_from_treasury<POINTS>(&mut Treasury): &mut Balance<POINTS>

32Call get_points_per_obj(): u64

33Call balance::split<POINTS>(&mut Balance<POINTS>, u64): Balance<POINTS>

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

35Call coin::from_balance<POINTS>(Balance<POINTS>, &mut TxContext): Coin<POINTS>

36MoveLoc[5](loc0: address)

37Call transfer::public_transfer<Coin<POINTS>>(Coin<POINTS>, address)

38Branch(43)

B5:

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

40Pop

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

42Pop

B6:

43Ret

}

Constants [

0 => u64: 1903824000000

1 => u64: 1966896000000

2 => u64: 63072000000

3 => u64: 0

4 => u64: 50

5 => u64: 1

6 => vector<u8>: "https://cro-ag.pages.dev/cronft.png" // interpreted as UTF8 string

7 => address: 0x0000060c049b5aea93660573019b2ed5d657245212a998e030981589726d11fe

8 => vector<u8>: "name" // interpreted as UTF8 string

9 => vector<u8>: "CroNft #{number}" // interpreted as UTF8 string

10 => vector<u8>: "description" // interpreted as UTF8 string

11 => vector<u8>: "image_url" // interpreted as UTF8 string

12 => vector<u8>: "minted_by" // interpreted as UTF8 string

13 => vector<u8>: "{minted_by}" // interpreted as UTF8 string

]

}