raffle_core

Module0xa761…aec3

Move path: 0xa761…aec3::raffle_core
Functions: 1816 public, 10 entry
Structs: 11
Friend modules: None

raffle_core

Bytecode2057 lines

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

// Move bytecode v6

module a76155b2b14cc3642a0df1e2e5741a71e83da2f99eeb5cf9dec40bcc8e01aec3.raffle_core {

use a76155b2b14cc3642a0df1e2e5741a71e83da2f99eeb5cf9dec40bcc8e01aec3::fee_manager;

use a76155b2b14cc3642a0df1e2e5741a71e83da2f99eeb5cf9dec40bcc8e01aec3::prize_vault;

use a76155b2b14cc3642a0df1e2e5741a71e83da2f99eeb5cf9dec40bcc8e01aec3::ticket_manager;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::display;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::random;

use 0000000000000000000000000000000000000000000000000000000000000002::sui;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;

struct RAFFLE_CORE has drop {

dummy_field: bool

}

struct AdminCap has store, key {

id: UID

}

struct Raffle has store, key {

id: UID,

creator: address,

name: String,

description: String,

image_url: String,

min_tickets: u64,

creation_time: u64,

end_time: u64,

is_active: bool,

winner: Option<address>,

winner_ticket_number: Option<u64>,

vault_id: ID,

ticket_manager_id: ID

}

struct RaffleRegistry has store, key {

id: UID,

active_raffles: VecSet<ID>,

completed_raffles: VecSet<ID>,

total_raffles_created: u64,

paused: bool

}

struct WinnerCertificate has store, key {

id: UID,

raffle_id: ID,

winner: address,

winning_ticket: u64

}

struct RaffleCreated has copy, drop {

raffle_id: ID,

creator: address,

prize_type: String,

prize_name: String,

name: String,

ticket_price: u64,

max_tickets: u64,

min_tickets: u64,

end_time: u64

}

struct WinnerSelected has copy, drop {

raffle_id: ID,

winner: address,

tickets_sold: u64,

winning_ticket: u64

}

struct PrizeClaimed has copy, drop {

prize_type: String,

prize_name: String

}

struct RaffleCancelled has copy, drop {

raffle_id: ID,

creator: address,

reason: String

}

struct SystemPauseToggled has copy, drop {

paused: bool,

toggled_by: address

}

struct ProceedsClaimed has copy, drop {

raffle_id: ID,

creator: address,

total_proceeds: u64,

platform_fee: u64,

creator_proceeds: u64,

claim_time: u64

}

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

L2: loc0: AdminCap

L3: loc1: Display<WinnerCertificate>

L4: loc2: Publisher

L5: loc3: Display<Raffle>

L6: loc4: RaffleRegistry

L7: loc5: address

B0:

0MoveLoc[0](Arg0: RAFFLE_CORE)

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

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

3StLoc[4](loc2: Publisher)

4ImmBorrowLoc[4](loc2: Publisher)

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

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

7StLoc[5](loc3: Display<Raffle>)

8MutBorrowLoc[5](loc3: Display<Raffle>)

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

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

11LdConst[14](vector<u8>: "{na..)

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

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

14MutBorrowLoc[5](loc3: Display<Raffle>)

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

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

17LdConst[16](vector<u8>: "{de..)

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

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

20MutBorrowLoc[5](loc3: Display<Raffle>)

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

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

23LdConst[18](vector<u8>: "{im..)

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

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

26MutBorrowLoc[5](loc3: Display<Raffle>)

27LdConst[19](vector<u8>: "cre..)

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

29LdConst[20](vector<u8>: "{cr..)

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

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

32MutBorrowLoc[5](loc3: Display<Raffle>)

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

34ImmBorrowLoc[4](loc2: Publisher)

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

36Call display::new<WinnerCertificate>(&Publisher, &mut TxContext): Display<WinnerCertificate>

37StLoc[3](loc1: Display<WinnerCertificate>)

38MutBorrowLoc[3](loc1: Display<WinnerCertificate>)

39LdConst[13](vector<u8>: "nam..)

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

41LdConst[21](vector<u8>: "Raf..)

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

43Call display::add<WinnerCertificate>(&mut Display<WinnerCertificate>, String, String)

44MutBorrowLoc[3](loc1: Display<WinnerCertificate>)

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

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

47LdConst[22](vector<u8>: "Cer..)

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

49Call display::add<WinnerCertificate>(&mut Display<WinnerCertificate>, String, String)

50MutBorrowLoc[3](loc1: Display<WinnerCertificate>)

51LdConst[17](vector<u8>: "ima..)

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

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

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

55Call display::add<WinnerCertificate>(&mut Display<WinnerCertificate>, String, String)

56MutBorrowLoc[3](loc1: Display<WinnerCertificate>)

57Call display::update_version<WinnerCertificate>(&mut Display<WinnerCertificate>)

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

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

60Pack[1](AdminCap)

61StLoc[2](loc0: AdminCap)

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

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

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

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

66LdU64(0)

67LdFalse

68Pack[3](RaffleRegistry)

69StLoc[6](loc4: RaffleRegistry)

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

71FreezeRef

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

73StLoc[7](loc5: address)

74MoveLoc[4](loc2: Publisher)

75CopyLoc[7](loc5: address)

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

77MoveLoc[5](loc3: Display<Raffle>)

78CopyLoc[7](loc5: address)

79Call transfer::public_transfer<Display<Raffle>>(Display<Raffle>, address)

80MoveLoc[3](loc1: Display<WinnerCertificate>)

81CopyLoc[7](loc5: address)

82Call transfer::public_transfer<Display<WinnerCertificate>>(Display<WinnerCertificate>, address)

83MoveLoc[2](loc0: AdminCap)

84MoveLoc[7](loc5: address)

85Call transfer::public_transfer<AdminCap>(AdminCap, address)

86MoveLoc[6](loc4: RaffleRegistry)

87Call transfer::public_share_object<RaffleRegistry>(RaffleRegistry)

88Ret

}

entry public toggle_system_pause(Arg0: &mut RaffleRegistry, Arg1: &AdminCap, Arg2: bool, Arg3: &mut TxContext) {

B0:

0CopyLoc[2](Arg2: bool)

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

2MutBorrowField[0](RaffleRegistry.paused: bool)

3WriteRef

4MoveLoc[2](Arg2: bool)

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

6FreezeRef

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

8Pack[9](SystemPauseToggled)

9Call event::emit<SystemPauseToggled>(SystemPauseToggled)

10Ret

}

entry public create_nft_raffle<Ty0: store + key>(Arg0: &mut RaffleRegistry, Arg1: &mut FeeManager, Arg2: Ty0, Arg3: &mut Coin<SUI>, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: vector<u8>, Arg9: u64, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: &Clock, Arg14: &mut TxContext) {

L15: loc0: u64

L16: loc1: Raffle

L17: loc2: ID

L18: loc3: DepositReceipt

L19: loc4: TicketManager

L20: loc5: PrizeVault

B0:

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

1ImmBorrowField[0](RaffleRegistry.paused: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(18)

B2:

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

7Pop

8MoveLoc[3](Arg3: &mut Coin<SUI>)

9Pop

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

11Pop

12MoveLoc[14](Arg14: &mut TxContext)

13Pop

14MoveLoc[13](Arg13: &Clock)

15Pop

16LdConst[9](u64: 11)

17Abort

B3:

18CopyLoc[12](Arg12: u64)

19LdU64(0)

20Gt

21BrFalse(23)

B4:

22Branch(35)

B5:

23MoveLoc[0](Arg0: &mut RaffleRegistry)

24Pop

25MoveLoc[3](Arg3: &mut Coin<SUI>)

26Pop

27MoveLoc[1](Arg1: &mut FeeManager)

28Pop

29MoveLoc[14](Arg14: &mut TxContext)

30Pop

31MoveLoc[13](Arg13: &Clock)

32Pop

33LdConst[6](u64: 8)

34Abort

B6:

35CopyLoc[11](Arg11: u64)

36CopyLoc[10](Arg10: u64)

37Le

38BrFalse(40)

B7:

39Branch(52)

B8:

40MoveLoc[0](Arg0: &mut RaffleRegistry)

41Pop

42MoveLoc[3](Arg3: &mut Coin<SUI>)

43Pop

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

45Pop

46MoveLoc[14](Arg14: &mut TxContext)

47Pop

48MoveLoc[13](Arg13: &Clock)

49Pop

50LdConst[7](u64: 9)

51Abort

B9:

52MoveLoc[13](Arg13: &Clock)

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

54StLoc[15](loc0: u64)

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

56MoveLoc[3](Arg3: &mut Coin<SUI>)

57LdConst[24](address: 0x00..)

58Call object::id_from_address(address): ID

59CopyLoc[15](loc0: u64)

60CopyLoc[14](Arg14: &mut TxContext)

61Call fee_manager::process_creation_fee(&mut FeeManager, &mut Coin<SUI>, ID, u64, &mut TxContext)

62MoveLoc[2](Arg2: Ty0)

63CopyLoc[7](Arg7: vector<u8>)

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

65MoveLoc[8](Arg8: vector<u8>)

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

67CopyLoc[15](loc0: u64)

68CopyLoc[14](Arg14: &mut TxContext)

69Call prize_vault::create_nft_vault<Ty0>(Ty0, String, String, u64, &mut TxContext): PrizeVault * DepositReceipt

70StLoc[18](loc3: DepositReceipt)

71StLoc[20](loc5: PrizeVault)

72ImmBorrowLoc[20](loc5: PrizeVault)

73Call object::id<PrizeVault>(&PrizeVault): ID

74CopyLoc[9](Arg9: u64)

75CopyLoc[10](Arg10: u64)

76CopyLoc[14](Arg14: &mut TxContext)

77Call ticket_manager::create_ticket_manager(ID, u64, u64, &mut TxContext): TicketManager

78StLoc[19](loc4: TicketManager)

79CopyLoc[14](Arg14: &mut TxContext)

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

81CopyLoc[14](Arg14: &mut TxContext)

82FreezeRef

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

84CopyLoc[4](Arg4: vector<u8>)

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

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

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

88MoveLoc[6](Arg6: vector<u8>)

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

90CopyLoc[11](Arg11: u64)

91CopyLoc[15](loc0: u64)

92CopyLoc[15](loc0: u64)

93CopyLoc[12](Arg12: u64)

94Add

95LdTrue

96Call option::none<address>(): Option<address>

97Call option::none<u64>(): Option<u64>

98ImmBorrowLoc[20](loc5: PrizeVault)

99Call object::id<PrizeVault>(&PrizeVault): ID

100ImmBorrowLoc[19](loc4: TicketManager)

101Call object::id<TicketManager>(&TicketManager): ID

102Pack[2](Raffle)

103StLoc[16](loc1: Raffle)

104ImmBorrowLoc[16](loc1: Raffle)

105Call object::id<Raffle>(&Raffle): ID

106StLoc[17](loc2: ID)

107CopyLoc[0](Arg0: &mut RaffleRegistry)

108MutBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

109CopyLoc[17](loc2: ID)

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

111CopyLoc[0](Arg0: &mut RaffleRegistry)

112ImmBorrowField[2](RaffleRegistry.total_raffles_created: u64)

113ReadRef

114LdU64(1)

115Add

116MoveLoc[0](Arg0: &mut RaffleRegistry)

117MutBorrowField[2](RaffleRegistry.total_raffles_created: u64)

118WriteRef

119MoveLoc[17](loc2: ID)

120CopyLoc[14](Arg14: &mut TxContext)

121FreezeRef

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

123LdConst[25](vector<u8>: "NFT..)

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

125MoveLoc[7](Arg7: vector<u8>)

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

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

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

129MoveLoc[9](Arg9: u64)

130MoveLoc[10](Arg10: u64)

131MoveLoc[11](Arg11: u64)

132MoveLoc[15](loc0: u64)

133MoveLoc[12](Arg12: u64)

134Add

135Pack[5](RaffleCreated)

136Call event::emit<RaffleCreated>(RaffleCreated)

137MoveLoc[18](loc3: DepositReceipt)

138MoveLoc[14](Arg14: &mut TxContext)

139FreezeRef

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

141Call transfer::public_transfer<DepositReceipt>(DepositReceipt, address)

142MoveLoc[20](loc5: PrizeVault)

143Call transfer::public_share_object<PrizeVault>(PrizeVault)

144MoveLoc[19](loc4: TicketManager)

145Call transfer::public_share_object<TicketManager>(TicketManager)

146MoveLoc[16](loc1: Raffle)

147Call transfer::public_share_object<Raffle>(Raffle)

148Ret

}

entry public create_kiosk_nft_raffle(Arg0: &mut RaffleRegistry, Arg1: &mut FeeManager, Arg2: ID, Arg3: ID, Arg4: ID, Arg5: vector<u8>, Arg6: &mut Coin<SUI>, Arg7: vector<u8>, Arg8: vector<u8>, Arg9: vector<u8>, Arg10: vector<u8>, Arg11: vector<u8>, Arg12: u64, Arg13: u64, Arg14: u64, Arg15: u64, Arg16: &Clock, Arg17: &mut TxContext) {

L18: loc0: u64

L19: loc1: Raffle

L20: loc2: ID

L21: loc3: DepositReceipt

L22: loc4: TicketManager

L23: loc5: PrizeVault

B0:

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

1ImmBorrowField[0](RaffleRegistry.paused: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(18)

B2:

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

7Pop

8MoveLoc[6](Arg6: &mut Coin<SUI>)

9Pop

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

11Pop

12MoveLoc[17](Arg17: &mut TxContext)

13Pop

14MoveLoc[16](Arg16: &Clock)

15Pop

16LdConst[9](u64: 11)

17Abort

B3:

18CopyLoc[15](Arg15: u64)

19LdU64(0)

20Gt

21BrFalse(23)

B4:

22Branch(35)

B5:

23MoveLoc[0](Arg0: &mut RaffleRegistry)

24Pop

25MoveLoc[6](Arg6: &mut Coin<SUI>)

26Pop

27MoveLoc[1](Arg1: &mut FeeManager)

28Pop

29MoveLoc[17](Arg17: &mut TxContext)

30Pop

31MoveLoc[16](Arg16: &Clock)

32Pop

33LdConst[6](u64: 8)

34Abort

B6:

35CopyLoc[14](Arg14: u64)

36CopyLoc[13](Arg13: u64)

37Le

38BrFalse(40)

B7:

39Branch(52)

B8:

40MoveLoc[0](Arg0: &mut RaffleRegistry)

41Pop

42MoveLoc[6](Arg6: &mut Coin<SUI>)

43Pop

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

45Pop

46MoveLoc[17](Arg17: &mut TxContext)

47Pop

48MoveLoc[16](Arg16: &Clock)

49Pop

50LdConst[7](u64: 9)

51Abort

B9:

52MoveLoc[16](Arg16: &Clock)

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

54StLoc[18](loc0: u64)

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

56MoveLoc[6](Arg6: &mut Coin<SUI>)

57LdConst[24](address: 0x00..)

58Call object::id_from_address(address): ID

59CopyLoc[18](loc0: u64)

60CopyLoc[17](Arg17: &mut TxContext)

61Call fee_manager::process_creation_fee(&mut FeeManager, &mut Coin<SUI>, ID, u64, &mut TxContext)

62MoveLoc[2](Arg2: ID)

63MoveLoc[3](Arg3: ID)

64MoveLoc[4](Arg4: ID)

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

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

67CopyLoc[10](Arg10: vector<u8>)

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

69MoveLoc[11](Arg11: vector<u8>)

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

71CopyLoc[18](loc0: u64)

72CopyLoc[17](Arg17: &mut TxContext)

73Call prize_vault::create_kiosk_nft_vault(ID, ID, ID, String, String, String, u64, &mut TxContext): PrizeVault * DepositReceipt

74StLoc[21](loc3: DepositReceipt)

75StLoc[23](loc5: PrizeVault)

76ImmBorrowLoc[23](loc5: PrizeVault)

77Call object::id<PrizeVault>(&PrizeVault): ID

78CopyLoc[12](Arg12: u64)

79CopyLoc[13](Arg13: u64)

80CopyLoc[17](Arg17: &mut TxContext)

81Call ticket_manager::create_ticket_manager(ID, u64, u64, &mut TxContext): TicketManager

82StLoc[22](loc4: TicketManager)

83CopyLoc[17](Arg17: &mut TxContext)

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

85CopyLoc[17](Arg17: &mut TxContext)

86FreezeRef

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

88CopyLoc[7](Arg7: vector<u8>)

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

90MoveLoc[8](Arg8: vector<u8>)

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

92MoveLoc[9](Arg9: vector<u8>)

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

94CopyLoc[14](Arg14: u64)

95CopyLoc[18](loc0: u64)

96CopyLoc[18](loc0: u64)

97CopyLoc[15](Arg15: u64)

98Add

99LdTrue

100Call option::none<address>(): Option<address>

101Call option::none<u64>(): Option<u64>

102ImmBorrowLoc[23](loc5: PrizeVault)

103Call object::id<PrizeVault>(&PrizeVault): ID

104ImmBorrowLoc[22](loc4: TicketManager)

105Call object::id<TicketManager>(&TicketManager): ID

106Pack[2](Raffle)

107StLoc[19](loc1: Raffle)

108ImmBorrowLoc[19](loc1: Raffle)

109Call object::id<Raffle>(&Raffle): ID

110StLoc[20](loc2: ID)

111CopyLoc[0](Arg0: &mut RaffleRegistry)

112MutBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

113CopyLoc[20](loc2: ID)

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

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

116ImmBorrowField[2](RaffleRegistry.total_raffles_created: u64)

117ReadRef

118LdU64(1)

119Add

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

121MutBorrowField[2](RaffleRegistry.total_raffles_created: u64)

122WriteRef

123MoveLoc[20](loc2: ID)

124CopyLoc[17](Arg17: &mut TxContext)

125FreezeRef

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

127LdConst[26](vector<u8>: "KIO..)

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

129MoveLoc[10](Arg10: vector<u8>)

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

131MoveLoc[7](Arg7: vector<u8>)

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

133MoveLoc[12](Arg12: u64)

134MoveLoc[13](Arg13: u64)

135MoveLoc[14](Arg14: u64)

136MoveLoc[18](loc0: u64)

137MoveLoc[15](Arg15: u64)

138Add

139Pack[5](RaffleCreated)

140Call event::emit<RaffleCreated>(RaffleCreated)

141MoveLoc[21](loc3: DepositReceipt)

142MoveLoc[17](Arg17: &mut TxContext)

143FreezeRef

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

145Call transfer::public_transfer<DepositReceipt>(DepositReceipt, address)

146MoveLoc[23](loc5: PrizeVault)

147Call transfer::public_share_object<PrizeVault>(PrizeVault)

148MoveLoc[22](loc4: TicketManager)

149Call transfer::public_share_object<TicketManager>(TicketManager)

150MoveLoc[19](loc1: Raffle)

151Call transfer::public_share_object<Raffle>(Raffle)

152Ret

}

entry public create_token_raffle(Arg0: &mut RaffleRegistry, Arg1: &mut FeeManager, Arg2: Coin<SUI>, Arg3: &mut Coin<SUI>, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: vector<u8>, Arg9: u64, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: &Clock, Arg14: &mut TxContext) {

L15: loc0: u64

L16: loc1: Raffle

L17: loc2: ID

L18: loc3: DepositReceipt

L19: loc4: TicketManager

L20: loc5: PrizeVault

B0:

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

1ImmBorrowField[0](RaffleRegistry.paused: bool)

2ReadRef

3Not

4BrFalse(6)

B1:

5Branch(18)

B2:

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

7Pop

8MoveLoc[3](Arg3: &mut Coin<SUI>)

9Pop

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

11Pop

12MoveLoc[14](Arg14: &mut TxContext)

13Pop

14MoveLoc[13](Arg13: &Clock)

15Pop

16LdConst[9](u64: 11)

17Abort

B3:

18CopyLoc[12](Arg12: u64)

19LdU64(0)

20Gt

21BrFalse(23)

B4:

22Branch(35)

B5:

23MoveLoc[0](Arg0: &mut RaffleRegistry)

24Pop

25MoveLoc[3](Arg3: &mut Coin<SUI>)

26Pop

27MoveLoc[1](Arg1: &mut FeeManager)

28Pop

29MoveLoc[14](Arg14: &mut TxContext)

30Pop

31MoveLoc[13](Arg13: &Clock)

32Pop

33LdConst[6](u64: 8)

34Abort

B6:

35CopyLoc[11](Arg11: u64)

36CopyLoc[10](Arg10: u64)

37Le

38BrFalse(40)

B7:

39Branch(52)

B8:

40MoveLoc[0](Arg0: &mut RaffleRegistry)

41Pop

42MoveLoc[3](Arg3: &mut Coin<SUI>)

43Pop

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

45Pop

46MoveLoc[14](Arg14: &mut TxContext)

47Pop

48MoveLoc[13](Arg13: &Clock)

49Pop

50LdConst[7](u64: 9)

51Abort

B9:

52MoveLoc[13](Arg13: &Clock)

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

54StLoc[15](loc0: u64)

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

56MoveLoc[3](Arg3: &mut Coin<SUI>)

57LdConst[24](address: 0x00..)

58Call object::id_from_address(address): ID

59CopyLoc[15](loc0: u64)

60CopyLoc[14](Arg14: &mut TxContext)

61Call fee_manager::process_creation_fee(&mut FeeManager, &mut Coin<SUI>, ID, u64, &mut TxContext)

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

63CopyLoc[7](Arg7: vector<u8>)

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

65MoveLoc[8](Arg8: vector<u8>)

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

67CopyLoc[15](loc0: u64)

68CopyLoc[14](Arg14: &mut TxContext)

69Call prize_vault::create_token_vault(Coin<SUI>, String, String, u64, &mut TxContext): PrizeVault * DepositReceipt

70StLoc[18](loc3: DepositReceipt)

71StLoc[20](loc5: PrizeVault)

72ImmBorrowLoc[20](loc5: PrizeVault)

73Call object::id<PrizeVault>(&PrizeVault): ID

74CopyLoc[9](Arg9: u64)

75CopyLoc[10](Arg10: u64)

76CopyLoc[14](Arg14: &mut TxContext)

77Call ticket_manager::create_ticket_manager(ID, u64, u64, &mut TxContext): TicketManager

78StLoc[19](loc4: TicketManager)

79CopyLoc[14](Arg14: &mut TxContext)

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

81CopyLoc[14](Arg14: &mut TxContext)

82FreezeRef

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

84CopyLoc[4](Arg4: vector<u8>)

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

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

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

88MoveLoc[6](Arg6: vector<u8>)

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

90CopyLoc[11](Arg11: u64)

91CopyLoc[15](loc0: u64)

92CopyLoc[15](loc0: u64)

93CopyLoc[12](Arg12: u64)

94Add

95LdTrue

96Call option::none<address>(): Option<address>

97Call option::none<u64>(): Option<u64>

98ImmBorrowLoc[20](loc5: PrizeVault)

99Call object::id<PrizeVault>(&PrizeVault): ID

100ImmBorrowLoc[19](loc4: TicketManager)

101Call object::id<TicketManager>(&TicketManager): ID

102Pack[2](Raffle)

103StLoc[16](loc1: Raffle)

104ImmBorrowLoc[16](loc1: Raffle)

105Call object::id<Raffle>(&Raffle): ID

106StLoc[17](loc2: ID)

107CopyLoc[0](Arg0: &mut RaffleRegistry)

108MutBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

109CopyLoc[17](loc2: ID)

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

111CopyLoc[0](Arg0: &mut RaffleRegistry)

112ImmBorrowField[2](RaffleRegistry.total_raffles_created: u64)

113ReadRef

114LdU64(1)

115Add

116MoveLoc[0](Arg0: &mut RaffleRegistry)

117MutBorrowField[2](RaffleRegistry.total_raffles_created: u64)

118WriteRef

119MoveLoc[17](loc2: ID)

120CopyLoc[14](Arg14: &mut TxContext)

121FreezeRef

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

123LdConst[27](vector<u8>: "TOK..)

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

125MoveLoc[7](Arg7: vector<u8>)

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

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

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

129MoveLoc[9](Arg9: u64)

130MoveLoc[10](Arg10: u64)

131MoveLoc[11](Arg11: u64)

132MoveLoc[15](loc0: u64)

133MoveLoc[12](Arg12: u64)

134Add

135Pack[5](RaffleCreated)

136Call event::emit<RaffleCreated>(RaffleCreated)

137MoveLoc[18](loc3: DepositReceipt)

138MoveLoc[14](Arg14: &mut TxContext)

139FreezeRef

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

141Call transfer::public_transfer<DepositReceipt>(DepositReceipt, address)

142MoveLoc[20](loc5: PrizeVault)

143Call transfer::public_share_object<PrizeVault>(PrizeVault)

144MoveLoc[19](loc4: TicketManager)

145Call transfer::public_share_object<TicketManager>(TicketManager)

146MoveLoc[16](loc1: Raffle)

147Call transfer::public_share_object<Raffle>(Raffle)

148Ret

}

entry public buy_tickets(Arg0: &Raffle, Arg1: &mut TicketManager, Arg2: &mut Coin<SUI>, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {

B0:

0CopyLoc[0](Arg0: &Raffle)

1ImmBorrowField[3](Raffle.is_active: bool)

2ReadRef

3BrFalse(5)

B1:

4Branch(17)

B2:

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

6Pop

7MoveLoc[0](Arg0: &Raffle)

8Pop

9MoveLoc[2](Arg2: &mut Coin<SUI>)

10Pop

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

12Pop

13MoveLoc[4](Arg4: &Clock)

14Pop

15LdConst[0](u64: 1)

16Abort

B3:

17CopyLoc[4](Arg4: &Clock)

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

19CopyLoc[0](Arg0: &Raffle)

20ImmBorrowField[4](Raffle.end_time: u64)

21ReadRef

22Lt

23BrFalse(25)

B4:

24Branch(37)

B5:

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

26Pop

27MoveLoc[0](Arg0: &Raffle)

28Pop

29MoveLoc[2](Arg2: &mut Coin<SUI>)

30Pop

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

32Pop

33MoveLoc[4](Arg4: &Clock)

34Pop

35LdConst[1](u64: 2)

36Abort

B6:

37CopyLoc[1](Arg1: &mut TicketManager)

38FreezeRef

39Call object::id<TicketManager>(&TicketManager): ID

40MoveLoc[0](Arg0: &Raffle)

41ImmBorrowField[5](Raffle.ticket_manager_id: ID)

42ReadRef

43Eq

44BrFalse(46)

B7:

45Branch(56)

B8:

46MoveLoc[1](Arg1: &mut TicketManager)

47Pop

48MoveLoc[2](Arg2: &mut Coin<SUI>)

49Pop

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

51Pop

52MoveLoc[4](Arg4: &Clock)

53Pop

54LdConst[10](u64: 12)

55Abort

B9:

56MoveLoc[1](Arg1: &mut TicketManager)

57MoveLoc[2](Arg2: &mut Coin<SUI>)

58MoveLoc[3](Arg3: u64)

59MoveLoc[4](Arg4: &Clock)

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

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

62Call ticket_manager::buy_tickets(&mut TicketManager, &mut Coin<SUI>, u64, u64, &mut TxContext): TicketBatch

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

64FreezeRef

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

66Call transfer::public_transfer<TicketBatch>(TicketBatch, address)

67Ret

}

entry public buy_individual_tickets(Arg0: &Raffle, Arg1: &mut TicketManager, Arg2: &mut Coin<SUI>, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {

B0:

0CopyLoc[0](Arg0: &Raffle)

1ImmBorrowField[3](Raffle.is_active: bool)

2ReadRef

3BrFalse(5)

B1:

4Branch(17)

B2:

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

6Pop

7MoveLoc[0](Arg0: &Raffle)

8Pop

9MoveLoc[2](Arg2: &mut Coin<SUI>)

10Pop

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

12Pop

13MoveLoc[4](Arg4: &Clock)

14Pop

15LdConst[0](u64: 1)

16Abort

B3:

17CopyLoc[4](Arg4: &Clock)

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

19CopyLoc[0](Arg0: &Raffle)

20ImmBorrowField[4](Raffle.end_time: u64)

21ReadRef

22Lt

23BrFalse(25)

B4:

24Branch(37)

B5:

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

26Pop

27MoveLoc[0](Arg0: &Raffle)

28Pop

29MoveLoc[2](Arg2: &mut Coin<SUI>)

30Pop

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

32Pop

33MoveLoc[4](Arg4: &Clock)

34Pop

35LdConst[1](u64: 2)

36Abort

B6:

37CopyLoc[1](Arg1: &mut TicketManager)

38FreezeRef

39Call object::id<TicketManager>(&TicketManager): ID

40MoveLoc[0](Arg0: &Raffle)

41ImmBorrowField[5](Raffle.ticket_manager_id: ID)

42ReadRef

43Eq

44BrFalse(46)

B7:

45Branch(56)

B8:

46MoveLoc[1](Arg1: &mut TicketManager)

47Pop

48MoveLoc[2](Arg2: &mut Coin<SUI>)

49Pop

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

51Pop

52MoveLoc[4](Arg4: &Clock)

53Pop

54LdConst[10](u64: 12)

55Abort

B9:

56MoveLoc[1](Arg1: &mut TicketManager)

57MoveLoc[2](Arg2: &mut Coin<SUI>)

58MoveLoc[3](Arg3: u64)

59MoveLoc[4](Arg4: &Clock)

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

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

62Call ticket_manager::buy_individual_tickets(&mut TicketManager, &mut Coin<SUI>, u64, u64, &mut TxContext)

63Ret

}

public has_met_min_tickets(Arg0: &Raffle, Arg1: &TicketManager): bool {

L2: loc0: u64

B0:

0CopyLoc[1](Arg1: &TicketManager)

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

2CopyLoc[0](Arg0: &Raffle)

3ImmBorrowField[5](Raffle.ticket_manager_id: ID)

4ReadRef

5Eq

6BrFalse(8)

B1:

7Branch(14)

B2:

8MoveLoc[1](Arg1: &TicketManager)

9Pop

10MoveLoc[0](Arg0: &Raffle)

11Pop

12LdConst[10](u64: 12)

13Abort

B3:

14MoveLoc[1](Arg1: &TicketManager)

15Call ticket_manager::get_manager_info(&TicketManager): ID * ID * address * u64 * u64 * u64 * u64 * bool

16Pop

17Pop

18StLoc[2](loc0: u64)

19Pop

20Pop

21Pop

22Pop

23Pop

24MoveLoc[2](loc0: u64)

25MoveLoc[0](Arg0: &Raffle)

26ImmBorrowField[6](Raffle.min_tickets: u64)

27ReadRef

28Ge

29Ret

}

determine_winner(Arg0: &TicketManager, Arg1: &Random, Arg2: &mut TxContext): address * u64 {

L3: loc0: RandomGenerator

L4: loc1: u64

L5: loc2: u64

B0:

0CopyLoc[0](Arg0: &TicketManager)

1Call ticket_manager::get_manager_info(&TicketManager): ID * ID * address * u64 * u64 * u64 * u64 * bool

2Pop

3Pop

4StLoc[4](loc1: u64)

5Pop

6Pop

7Pop

8Pop

9Pop

10MoveLoc[1](Arg1: &Random)

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

12Call random::new_generator(&Random, &mut TxContext): RandomGenerator

13StLoc[3](loc0: RandomGenerator)

14MutBorrowLoc[3](loc0: RandomGenerator)

15LdU64(0)

16MoveLoc[4](loc1: u64)

17LdU64(1)

18Sub

19Call random::generate_u64_in_range(&mut RandomGenerator, u64, u64): u64

20StLoc[5](loc2: u64)

21MoveLoc[0](Arg0: &TicketManager)

22CopyLoc[5](loc2: u64)

23Call ticket_manager::find_ticket_owner(&TicketManager, u64): address

24MoveLoc[5](loc2: u64)

25Ret

}

entry public select_winner(Arg0: &mut RaffleRegistry, Arg1: &mut Raffle, Arg2: &mut TicketManager, Arg3: &mut PrizeVault, Arg4: &Random, Arg5: &Clock, Arg6: &mut TxContext) {

L7: loc0: u64

L8: loc1: &mut TxContext

L9: loc2: &Random

L10: loc3: &mut TxContext

L11: loc4: ID

L12: loc5: &VecSet<ID>

L13: loc6: ID

L14: loc7: &mut VecSet<ID>

L15: loc8: address

L16: loc9: WinnerCertificate

L17: loc10: ClaimTicket

L18: loc11: u64

L19: loc12: address

L20: loc13: u64

B0:

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

1ImmBorrowField[3](Raffle.is_active: bool)

2ReadRef

3BrFalse(5)

B1:

4Branch(21)

B2:

5MoveLoc[3](Arg3: &mut PrizeVault)

6Pop

7MoveLoc[2](Arg2: &mut TicketManager)

8Pop

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

10Pop

11MoveLoc[4](Arg4: &Random)

12Pop

13MoveLoc[1](Arg1: &mut Raffle)

14Pop

15MoveLoc[6](Arg6: &mut TxContext)

16Pop

17MoveLoc[5](Arg5: &Clock)

18Pop

19LdConst[0](u64: 1)

20Abort

B3:

21CopyLoc[5](Arg5: &Clock)

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

23CopyLoc[1](Arg1: &mut Raffle)

24ImmBorrowField[4](Raffle.end_time: u64)

25ReadRef

26Ge

27BrFalse(29)

B4:

28Branch(45)

B5:

29MoveLoc[3](Arg3: &mut PrizeVault)

30Pop

31MoveLoc[2](Arg2: &mut TicketManager)

32Pop

33MoveLoc[0](Arg0: &mut RaffleRegistry)

34Pop

35MoveLoc[4](Arg4: &Random)

36Pop

37MoveLoc[1](Arg1: &mut Raffle)

38Pop

39MoveLoc[6](Arg6: &mut TxContext)

40Pop

41MoveLoc[5](Arg5: &Clock)

42Pop

43LdConst[2](u64: 3)

44Abort

B6:

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

46ImmBorrowField[7](Raffle.winner: Option<address>)

47Call option::is_none<address>(&Option<address>): bool

48BrFalse(50)

B7:

49Branch(66)

B8:

50MoveLoc[3](Arg3: &mut PrizeVault)

51Pop

52MoveLoc[2](Arg2: &mut TicketManager)

53Pop

54MoveLoc[0](Arg0: &mut RaffleRegistry)

55Pop

56MoveLoc[4](Arg4: &Random)

57Pop

58MoveLoc[1](Arg1: &mut Raffle)

59Pop

60MoveLoc[6](Arg6: &mut TxContext)

61Pop

62MoveLoc[5](Arg5: &Clock)

63Pop

64LdConst[4](u64: 5)

65Abort

B9:

66CopyLoc[2](Arg2: &mut TicketManager)

67FreezeRef

68Call object::id<TicketManager>(&TicketManager): ID

69CopyLoc[1](Arg1: &mut Raffle)

70ImmBorrowField[5](Raffle.ticket_manager_id: ID)

71ReadRef

72Eq

73BrFalse(75)

B10:

74Branch(91)

B11:

75MoveLoc[3](Arg3: &mut PrizeVault)

76Pop

77MoveLoc[2](Arg2: &mut TicketManager)

78Pop

79MoveLoc[0](Arg0: &mut RaffleRegistry)

80Pop

81MoveLoc[4](Arg4: &Random)

82Pop

83MoveLoc[1](Arg1: &mut Raffle)

84Pop

85MoveLoc[6](Arg6: &mut TxContext)

86Pop

87MoveLoc[5](Arg5: &Clock)

88Pop

89LdConst[10](u64: 12)

90Abort

B12:

91CopyLoc[3](Arg3: &mut PrizeVault)

92FreezeRef

93Call object::id<PrizeVault>(&PrizeVault): ID

94CopyLoc[1](Arg1: &mut Raffle)

95ImmBorrowField[8](Raffle.vault_id: ID)

96ReadRef

97Eq

98BrFalse(100)

B13:

99Branch(116)

B14:

100MoveLoc[3](Arg3: &mut PrizeVault)

101Pop

102MoveLoc[2](Arg2: &mut TicketManager)

103Pop

104MoveLoc[0](Arg0: &mut RaffleRegistry)

105Pop

106MoveLoc[4](Arg4: &Random)

107Pop

108MoveLoc[1](Arg1: &mut Raffle)

109Pop

110MoveLoc[6](Arg6: &mut TxContext)

111Pop

112MoveLoc[5](Arg5: &Clock)

113Pop

114LdConst[10](u64: 12)

115Abort

B15:

116CopyLoc[2](Arg2: &mut TicketManager)

117FreezeRef

118Call ticket_manager::get_manager_info(&TicketManager): ID * ID * address * u64 * u64 * u64 * u64 * bool

119Pop

120Pop

121StLoc[18](loc11: u64)

122Pop

123Pop

124Pop

125Pop

126Pop

127CopyLoc[18](loc11: u64)

128CopyLoc[1](Arg1: &mut Raffle)

129ImmBorrowField[6](Raffle.min_tickets: u64)

130ReadRef

131Ge

132BrFalse(134)

B16:

133Branch(150)

B17:

134MoveLoc[3](Arg3: &mut PrizeVault)

135Pop

136MoveLoc[2](Arg2: &mut TicketManager)

137Pop

138MoveLoc[0](Arg0: &mut RaffleRegistry)

139Pop

140MoveLoc[4](Arg4: &Random)

141Pop

142MoveLoc[1](Arg1: &mut Raffle)

143Pop

144MoveLoc[6](Arg6: &mut TxContext)

145Pop

146MoveLoc[5](Arg5: &Clock)

147Pop

148LdConst[3](u64: 4)

149Abort

B18:

150CopyLoc[2](Arg2: &mut TicketManager)

151MoveLoc[4](Arg4: &Random)

152CopyLoc[6](Arg6: &mut TxContext)

153StLoc[10](loc3: &mut TxContext)

154StLoc[9](loc2: &Random)

155FreezeRef

156MoveLoc[9](loc2: &Random)

157MoveLoc[10](loc3: &mut TxContext)

158Call determine_winner(&TicketManager, &Random, &mut TxContext): address * u64

159StLoc[20](loc13: u64)

160StLoc[19](loc12: address)

161CopyLoc[19](loc12: address)

162Call option::some<address>(address): Option<address>

163CopyLoc[1](Arg1: &mut Raffle)

164MutBorrowField[7](Raffle.winner: Option<address>)

165WriteRef

166CopyLoc[20](loc13: u64)

167Call option::some<u64>(u64): Option<u64>

168CopyLoc[1](Arg1: &mut Raffle)

169MutBorrowField[9](Raffle.winner_ticket_number: Option<u64>)

170WriteRef

171LdFalse

172CopyLoc[1](Arg1: &mut Raffle)

173MutBorrowField[3](Raffle.is_active: bool)

174WriteRef

175CopyLoc[0](Arg0: &mut RaffleRegistry)

176ImmBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

177StLoc[12](loc5: &VecSet<ID>)

178CopyLoc[1](Arg1: &mut Raffle)

179FreezeRef

180Call object::id<Raffle>(&Raffle): ID

181StLoc[11](loc4: ID)

182MoveLoc[12](loc5: &VecSet<ID>)

183ImmBorrowLoc[11](loc4: ID)

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

185BrFalse(203)

B19:

186CopyLoc[0](Arg0: &mut RaffleRegistry)

187MutBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

188StLoc[14](loc7: &mut VecSet<ID>)

189CopyLoc[1](Arg1: &mut Raffle)

190FreezeRef

191Call object::id<Raffle>(&Raffle): ID

192StLoc[13](loc6: ID)

193MoveLoc[14](loc7: &mut VecSet<ID>)

194ImmBorrowLoc[13](loc6: ID)

195Call vec_set::remove<ID>(&mut VecSet<ID>, &ID)

196MoveLoc[0](Arg0: &mut RaffleRegistry)

197MutBorrowField[10](RaffleRegistry.completed_raffles: VecSet<ID>)

198CopyLoc[1](Arg1: &mut Raffle)

199FreezeRef

200Call object::id<Raffle>(&Raffle): ID

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

202Branch(205)

B20:

203MoveLoc[0](Arg0: &mut RaffleRegistry)

204Pop

B21:

205MoveLoc[2](Arg2: &mut TicketManager)

206CopyLoc[6](Arg6: &mut TxContext)

207Call ticket_manager::deactivate(&mut TicketManager, &mut TxContext)

208CopyLoc[6](Arg6: &mut TxContext)

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

210CopyLoc[1](Arg1: &mut Raffle)

211FreezeRef

212Call object::id<Raffle>(&Raffle): ID

213CopyLoc[19](loc12: address)

214CopyLoc[20](loc13: u64)

215Pack[4](WinnerCertificate)

216StLoc[16](loc9: WinnerCertificate)

217MoveLoc[3](Arg3: &mut PrizeVault)

218CopyLoc[19](loc12: address)

219MoveLoc[5](Arg5: &Clock)

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

221MoveLoc[6](Arg6: &mut TxContext)

222StLoc[8](loc1: &mut TxContext)

223StLoc[7](loc0: u64)

224StLoc[15](loc8: address)

225FreezeRef

226MoveLoc[15](loc8: address)

227MoveLoc[7](loc0: u64)

228MoveLoc[8](loc1: &mut TxContext)

229Call prize_vault::issue_claim_ticket(&PrizeVault, address, u64, &mut TxContext): ClaimTicket

230StLoc[17](loc10: ClaimTicket)

231MoveLoc[1](Arg1: &mut Raffle)

232FreezeRef

233Call object::id<Raffle>(&Raffle): ID

234CopyLoc[19](loc12: address)

235MoveLoc[18](loc11: u64)

236MoveLoc[20](loc13: u64)

237Pack[6](WinnerSelected)

238Call event::emit<WinnerSelected>(WinnerSelected)

239MoveLoc[16](loc9: WinnerCertificate)

240CopyLoc[19](loc12: address)

241Call transfer::public_transfer<WinnerCertificate>(WinnerCertificate, address)

242MoveLoc[17](loc10: ClaimTicket)

243MoveLoc[19](loc12: address)

244Call transfer::public_transfer<ClaimTicket>(ClaimTicket, address)

245Ret

}

entry public process_refunds(Arg0: &mut RaffleRegistry, Arg1: &mut Raffle, Arg2: &mut TicketManager, Arg3: &mut PrizeVault, Arg4: DepositReceipt, Arg5: &Clock, Arg6: &mut TxContext) {

L7: loc0: ID

L8: loc1: &VecSet<ID>

L9: loc2: ID

L10: loc3: &mut VecSet<ID>

L11: loc4: u64

B0:

0CopyLoc[5](Arg5: &Clock)

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

2CopyLoc[1](Arg1: &mut Raffle)

3ImmBorrowField[4](Raffle.end_time: u64)

4ReadRef

5Ge

6BrFalse(8)

B1:

7Branch(22)

B2:

8MoveLoc[3](Arg3: &mut PrizeVault)

9Pop

10MoveLoc[2](Arg2: &mut TicketManager)

11Pop

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

13Pop

14MoveLoc[1](Arg1: &mut Raffle)

15Pop

16MoveLoc[6](Arg6: &mut TxContext)

17Pop

18MoveLoc[5](Arg5: &Clock)

19Pop

20LdConst[2](u64: 3)

21Abort

B3:

22CopyLoc[1](Arg1: &mut Raffle)

23ImmBorrowField[3](Raffle.is_active: bool)

24ReadRef

25BrFalse(27)

B4:

26Branch(41)

B5:

27MoveLoc[3](Arg3: &mut PrizeVault)

28Pop

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

30Pop

31MoveLoc[0](Arg0: &mut RaffleRegistry)

32Pop

33MoveLoc[1](Arg1: &mut Raffle)

34Pop

35MoveLoc[6](Arg6: &mut TxContext)

36Pop

37MoveLoc[5](Arg5: &Clock)

38Pop

39LdConst[0](u64: 1)

40Abort

B6:

41CopyLoc[2](Arg2: &mut TicketManager)

42FreezeRef

43Call object::id<TicketManager>(&TicketManager): ID

44CopyLoc[1](Arg1: &mut Raffle)

45ImmBorrowField[5](Raffle.ticket_manager_id: ID)

46ReadRef

47Eq

48BrFalse(50)

B7:

49Branch(64)

B8:

50MoveLoc[3](Arg3: &mut PrizeVault)

51Pop

52MoveLoc[2](Arg2: &mut TicketManager)

53Pop

54MoveLoc[0](Arg0: &mut RaffleRegistry)

55Pop

56MoveLoc[1](Arg1: &mut Raffle)

57Pop

58MoveLoc[6](Arg6: &mut TxContext)

59Pop

60MoveLoc[5](Arg5: &Clock)

61Pop

62LdConst[10](u64: 12)

63Abort

B9:

64CopyLoc[3](Arg3: &mut PrizeVault)

65FreezeRef

66Call object::id<PrizeVault>(&PrizeVault): ID

67CopyLoc[1](Arg1: &mut Raffle)

68ImmBorrowField[8](Raffle.vault_id: ID)

69ReadRef

70Eq

71BrFalse(73)

B10:

72Branch(87)

B11:

73MoveLoc[3](Arg3: &mut PrizeVault)

74Pop

75MoveLoc[2](Arg2: &mut TicketManager)

76Pop

77MoveLoc[0](Arg0: &mut RaffleRegistry)

78Pop

79MoveLoc[1](Arg1: &mut Raffle)

80Pop

81MoveLoc[6](Arg6: &mut TxContext)

82Pop

83MoveLoc[5](Arg5: &Clock)

84Pop

85LdConst[10](u64: 12)

86Abort

B12:

87CopyLoc[6](Arg6: &mut TxContext)

88FreezeRef

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

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

91ImmBorrowField[11](Raffle.creator: address)

92ReadRef

93Eq

94BrFalse(96)

B13:

95Branch(110)

B14:

96MoveLoc[3](Arg3: &mut PrizeVault)

97Pop

98MoveLoc[2](Arg2: &mut TicketManager)

99Pop

100MoveLoc[0](Arg0: &mut RaffleRegistry)

101Pop

102MoveLoc[1](Arg1: &mut Raffle)

103Pop

104MoveLoc[6](Arg6: &mut TxContext)

105Pop

106MoveLoc[5](Arg5: &Clock)

107Pop

108LdConst[5](u64: 7)

109Abort

B15:

110CopyLoc[2](Arg2: &mut TicketManager)

111FreezeRef

112Call ticket_manager::get_manager_info(&TicketManager): ID * ID * address * u64 * u64 * u64 * u64 * bool

113Pop

114Pop

115StLoc[11](loc4: u64)

116Pop

117Pop

118Pop

119Pop

120Pop

121MoveLoc[11](loc4: u64)

122CopyLoc[1](Arg1: &mut Raffle)

123ImmBorrowField[6](Raffle.min_tickets: u64)

124ReadRef

125Lt

126BrFalse(128)

B16:

127Branch(142)

B17:

128MoveLoc[3](Arg3: &mut PrizeVault)

129Pop

130MoveLoc[2](Arg2: &mut TicketManager)

131Pop

132MoveLoc[0](Arg0: &mut RaffleRegistry)

133Pop

134MoveLoc[1](Arg1: &mut Raffle)

135Pop

136MoveLoc[6](Arg6: &mut TxContext)

137Pop

138MoveLoc[5](Arg5: &Clock)

139Pop

140LdConst[8](u64: 10)

141Abort

B18:

142MoveLoc[2](Arg2: &mut TicketManager)

143CopyLoc[6](Arg6: &mut TxContext)

144Call ticket_manager::process_refunds(&mut TicketManager, &mut TxContext)

145CopyLoc[3](Arg3: &mut PrizeVault)

146FreezeRef

147Call prize_vault::get_prize_type(&PrizeVault): String

148LdConst[27](vector<u8>: "TOK..)

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

150Eq

151BrFalse(153)

B19:

152Branch(165)

B20:

153MoveLoc[3](Arg3: &mut PrizeVault)

154Pop

155MoveLoc[0](Arg0: &mut RaffleRegistry)

156Pop

157MoveLoc[1](Arg1: &mut Raffle)

158Pop

159MoveLoc[6](Arg6: &mut TxContext)

160Pop

161MoveLoc[5](Arg5: &Clock)

162Pop

163LdConst[11](u64: 13)

164Abort

B21:

165MoveLoc[3](Arg3: &mut PrizeVault)

166MoveLoc[4](Arg4: DepositReceipt)

167MoveLoc[5](Arg5: &Clock)

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

169MoveLoc[6](Arg6: &mut TxContext)

170Call prize_vault::reclaim_prize<Coin<SUI>>(&mut PrizeVault, DepositReceipt, u64, &mut TxContext)

171LdFalse

172CopyLoc[1](Arg1: &mut Raffle)

173MutBorrowField[3](Raffle.is_active: bool)

174WriteRef

175CopyLoc[0](Arg0: &mut RaffleRegistry)

176ImmBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

177StLoc[8](loc1: &VecSet<ID>)

178CopyLoc[1](Arg1: &mut Raffle)

179FreezeRef

180Call object::id<Raffle>(&Raffle): ID

181StLoc[7](loc0: ID)

182MoveLoc[8](loc1: &VecSet<ID>)

183ImmBorrowLoc[7](loc0: ID)

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

185BrFalse(203)

B22:

186CopyLoc[0](Arg0: &mut RaffleRegistry)

187MutBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

188StLoc[10](loc3: &mut VecSet<ID>)

189CopyLoc[1](Arg1: &mut Raffle)

190FreezeRef

191Call object::id<Raffle>(&Raffle): ID

192StLoc[9](loc2: ID)

193MoveLoc[10](loc3: &mut VecSet<ID>)

194ImmBorrowLoc[9](loc2: ID)

195Call vec_set::remove<ID>(&mut VecSet<ID>, &ID)

196MoveLoc[0](Arg0: &mut RaffleRegistry)

197MutBorrowField[10](RaffleRegistry.completed_raffles: VecSet<ID>)

198CopyLoc[1](Arg1: &mut Raffle)

199FreezeRef

200Call object::id<Raffle>(&Raffle): ID

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

202Branch(205)

B23:

203MoveLoc[0](Arg0: &mut RaffleRegistry)

204Pop

B24:

205CopyLoc[1](Arg1: &mut Raffle)

206FreezeRef

207Call object::id<Raffle>(&Raffle): ID

208MoveLoc[1](Arg1: &mut Raffle)

209ImmBorrowField[11](Raffle.creator: address)

210ReadRef

211LdConst[28](vector<u8>: "Min..)

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

213Pack[8](RaffleCancelled)

214Call event::emit<RaffleCancelled>(RaffleCancelled)

215Ret

}

entry public cancel_raffle(Arg0: &mut RaffleRegistry, Arg1: &mut Raffle, Arg2: &mut TicketManager, Arg3: &mut PrizeVault, Arg4: DepositReceipt, Arg5: vector<u8>, Arg6: &mut TxContext) {

L7: loc0: ID

L8: loc1: &VecSet<ID>

L9: loc2: ID

L10: loc3: &mut VecSet<ID>

L11: loc4: u64

B0:

0CopyLoc[6](Arg6: &mut TxContext)

1FreezeRef

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

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

4ImmBorrowField[11](Raffle.creator: address)

5ReadRef

6Eq

7BrFalse(9)

B1:

8Branch(21)

B2:

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

10Pop

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

12Pop

13MoveLoc[0](Arg0: &mut RaffleRegistry)

14Pop

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

16Pop

17MoveLoc[6](Arg6: &mut TxContext)

18Pop

19LdConst[5](u64: 7)

20Abort

B3:

21CopyLoc[1](Arg1: &mut Raffle)

22ImmBorrowField[3](Raffle.is_active: bool)

23ReadRef

24BrFalse(26)

B4:

25Branch(38)

B5:

26MoveLoc[3](Arg3: &mut PrizeVault)

27Pop

28MoveLoc[2](Arg2: &mut TicketManager)

29Pop

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

31Pop

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

33Pop

34MoveLoc[6](Arg6: &mut TxContext)

35Pop

36LdConst[0](u64: 1)

37Abort

B6:

38CopyLoc[2](Arg2: &mut TicketManager)

39FreezeRef

40Call object::id<TicketManager>(&TicketManager): ID

41CopyLoc[1](Arg1: &mut Raffle)

42ImmBorrowField[5](Raffle.ticket_manager_id: ID)

43ReadRef

44Eq

45BrFalse(47)

B7:

46Branch(59)

B8:

47MoveLoc[3](Arg3: &mut PrizeVault)

48Pop

49MoveLoc[2](Arg2: &mut TicketManager)

50Pop

51MoveLoc[0](Arg0: &mut RaffleRegistry)

52Pop

53MoveLoc[1](Arg1: &mut Raffle)

54Pop

55MoveLoc[6](Arg6: &mut TxContext)

56Pop

57LdConst[10](u64: 12)

58Abort

B9:

59CopyLoc[3](Arg3: &mut PrizeVault)

60FreezeRef

61Call object::id<PrizeVault>(&PrizeVault): ID

62CopyLoc[1](Arg1: &mut Raffle)

63ImmBorrowField[8](Raffle.vault_id: ID)

64ReadRef

65Eq

66BrFalse(68)

B10:

67Branch(80)

B11:

68MoveLoc[3](Arg3: &mut PrizeVault)

69Pop

70MoveLoc[2](Arg2: &mut TicketManager)

71Pop

72MoveLoc[0](Arg0: &mut RaffleRegistry)

73Pop

74MoveLoc[1](Arg1: &mut Raffle)

75Pop

76MoveLoc[6](Arg6: &mut TxContext)

77Pop

78LdConst[10](u64: 12)

79Abort

B12:

80CopyLoc[2](Arg2: &mut TicketManager)

81FreezeRef

82Call ticket_manager::get_manager_info(&TicketManager): ID * ID * address * u64 * u64 * u64 * u64 * bool

83Pop

84Pop

85StLoc[11](loc4: u64)

86Pop

87Pop

88Pop

89Pop

90Pop

91MoveLoc[11](loc4: u64)

92LdU64(0)

93Gt

94BrFalse(99)

B13:

95MoveLoc[2](Arg2: &mut TicketManager)

96CopyLoc[6](Arg6: &mut TxContext)

97Call ticket_manager::process_refunds(&mut TicketManager, &mut TxContext)

98Branch(101)

B14:

99MoveLoc[2](Arg2: &mut TicketManager)

100Pop

B15:

101CopyLoc[3](Arg3: &mut PrizeVault)

102FreezeRef

103Call prize_vault::get_prize_type(&PrizeVault): String

104LdConst[27](vector<u8>: "TOK..)

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

106Eq

107BrFalse(109)

B16:

108Branch(119)

B17:

109MoveLoc[3](Arg3: &mut PrizeVault)

110Pop

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

112Pop

113MoveLoc[1](Arg1: &mut Raffle)

114Pop

115MoveLoc[6](Arg6: &mut TxContext)

116Pop

117LdConst[11](u64: 13)

118Abort

B18:

119MoveLoc[3](Arg3: &mut PrizeVault)

120MoveLoc[4](Arg4: DepositReceipt)

121CopyLoc[6](Arg6: &mut TxContext)

122FreezeRef

123Call tx_context::epoch(&TxContext): u64

124MoveLoc[6](Arg6: &mut TxContext)

125Call prize_vault::reclaim_prize<Coin<SUI>>(&mut PrizeVault, DepositReceipt, u64, &mut TxContext)

126LdFalse

127CopyLoc[1](Arg1: &mut Raffle)

128MutBorrowField[3](Raffle.is_active: bool)

129WriteRef

130Call option::none<address>(): Option<address>

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

132MutBorrowField[7](Raffle.winner: Option<address>)

133WriteRef

134CopyLoc[0](Arg0: &mut RaffleRegistry)

135ImmBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

136StLoc[8](loc1: &VecSet<ID>)

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

138FreezeRef

139Call object::id<Raffle>(&Raffle): ID

140StLoc[7](loc0: ID)

141MoveLoc[8](loc1: &VecSet<ID>)

142ImmBorrowLoc[7](loc0: ID)

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

144BrFalse(162)

B19:

145CopyLoc[0](Arg0: &mut RaffleRegistry)

146MutBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

147StLoc[10](loc3: &mut VecSet<ID>)

148CopyLoc[1](Arg1: &mut Raffle)

149FreezeRef

150Call object::id<Raffle>(&Raffle): ID

151StLoc[9](loc2: ID)

152MoveLoc[10](loc3: &mut VecSet<ID>)

153ImmBorrowLoc[9](loc2: ID)

154Call vec_set::remove<ID>(&mut VecSet<ID>, &ID)

155MoveLoc[0](Arg0: &mut RaffleRegistry)

156MutBorrowField[10](RaffleRegistry.completed_raffles: VecSet<ID>)

157CopyLoc[1](Arg1: &mut Raffle)

158FreezeRef

159Call object::id<Raffle>(&Raffle): ID

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

161Branch(164)

B20:

162MoveLoc[0](Arg0: &mut RaffleRegistry)

163Pop

B21:

164CopyLoc[1](Arg1: &mut Raffle)

165FreezeRef

166Call object::id<Raffle>(&Raffle): ID

167MoveLoc[1](Arg1: &mut Raffle)

168ImmBorrowField[11](Raffle.creator: address)

169ReadRef

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

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

172Pack[8](RaffleCancelled)

173Call event::emit<RaffleCancelled>(RaffleCancelled)

174Ret

}

public get_raffle_info(Arg0: &Raffle): ID * address * String * String * String * u64 * u64 * u64 * bool * Option<address> * Option<u64> * ID * ID {

B0:

0CopyLoc[0](Arg0: &Raffle)

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

2CopyLoc[0](Arg0: &Raffle)

3ImmBorrowField[11](Raffle.creator: address)

4ReadRef

5CopyLoc[0](Arg0: &Raffle)

6ImmBorrowField[12](Raffle.name: String)

7ReadRef

8CopyLoc[0](Arg0: &Raffle)

9ImmBorrowField[13](Raffle.description: String)

10ReadRef

11CopyLoc[0](Arg0: &Raffle)

12ImmBorrowField[14](Raffle.image_url: String)

13ReadRef

14CopyLoc[0](Arg0: &Raffle)

15ImmBorrowField[6](Raffle.min_tickets: u64)

16ReadRef

17CopyLoc[0](Arg0: &Raffle)

18ImmBorrowField[15](Raffle.creation_time: u64)

19ReadRef

20CopyLoc[0](Arg0: &Raffle)

21ImmBorrowField[4](Raffle.end_time: u64)

22ReadRef

23CopyLoc[0](Arg0: &Raffle)

24ImmBorrowField[3](Raffle.is_active: bool)

25ReadRef

26CopyLoc[0](Arg0: &Raffle)

27ImmBorrowField[7](Raffle.winner: Option<address>)

28ReadRef

29CopyLoc[0](Arg0: &Raffle)

30ImmBorrowField[9](Raffle.winner_ticket_number: Option<u64>)

31ReadRef

32CopyLoc[0](Arg0: &Raffle)

33ImmBorrowField[8](Raffle.vault_id: ID)

34ReadRef

35MoveLoc[0](Arg0: &Raffle)

36ImmBorrowField[5](Raffle.ticket_manager_id: ID)

37ReadRef

38Ret

}

public get_active_raffles(Arg0: &RaffleRegistry): vector<ID> {

L1: loc0: u64

L2: loc1: u64

L3: loc2: vector<ID>

L4: loc3: vector<ID>

B0:

0VecPack(36, 0)

1StLoc[4](loc3: vector<ID>)

2MoveLoc[0](Arg0: &RaffleRegistry)

3ImmBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

4ReadRef

5Call vec_set::into_keys<ID>(VecSet<ID>): vector<ID>

6StLoc[3](loc2: vector<ID>)

7LdU64(0)

8StLoc[1](loc0: u64)

9ImmBorrowLoc[3](loc2: vector<ID>)

10VecLen(36)

11StLoc[2](loc1: u64)

B1:

12CopyLoc[1](loc0: u64)

13CopyLoc[2](loc1: u64)

14Lt

15BrFalse(28)

B2:

16Branch(17)

B3:

17MutBorrowLoc[4](loc3: vector<ID>)

18ImmBorrowLoc[3](loc2: vector<ID>)

19CopyLoc[1](loc0: u64)

20VecImmBorrow(36)

21ReadRef

22VecPushBack(36)

23MoveLoc[1](loc0: u64)

24LdU64(1)

25Add

26StLoc[1](loc0: u64)

27Branch(12)

B4:

28MoveLoc[4](loc3: vector<ID>)

29Ret

}

public get_completed_raffles(Arg0: &RaffleRegistry): vector<ID> {

L1: loc0: u64

L2: loc1: u64

L3: loc2: vector<ID>

L4: loc3: vector<ID>

B0:

0VecPack(36, 0)

1StLoc[4](loc3: vector<ID>)

2MoveLoc[0](Arg0: &RaffleRegistry)

3ImmBorrowField[10](RaffleRegistry.completed_raffles: VecSet<ID>)

4ReadRef

5Call vec_set::into_keys<ID>(VecSet<ID>): vector<ID>

6StLoc[3](loc2: vector<ID>)

7LdU64(0)

8StLoc[1](loc0: u64)

9ImmBorrowLoc[3](loc2: vector<ID>)

10VecLen(36)

11StLoc[2](loc1: u64)

B1:

12CopyLoc[1](loc0: u64)

13CopyLoc[2](loc1: u64)

14Lt

15BrFalse(28)

B2:

16Branch(17)

B3:

17MutBorrowLoc[4](loc3: vector<ID>)

18ImmBorrowLoc[3](loc2: vector<ID>)

19CopyLoc[1](loc0: u64)

20VecImmBorrow(36)

21ReadRef

22VecPushBack(36)

23MoveLoc[1](loc0: u64)

24LdU64(1)

25Add

26StLoc[1](loc0: u64)

27Branch(12)

B4:

28MoveLoc[4](loc3: vector<ID>)

29Ret

}

public get_registry_stats(Arg0: &RaffleRegistry): u64 * u64 * u64 * bool {

B0:

0CopyLoc[0](Arg0: &RaffleRegistry)

1ImmBorrowField[2](RaffleRegistry.total_raffles_created: u64)

2ReadRef

3CopyLoc[0](Arg0: &RaffleRegistry)

4ImmBorrowField[1](RaffleRegistry.active_raffles: VecSet<ID>)

5Call vec_set::size<ID>(&VecSet<ID>): u64

6CopyLoc[0](Arg0: &RaffleRegistry)

7ImmBorrowField[10](RaffleRegistry.completed_raffles: VecSet<ID>)

8Call vec_set::size<ID>(&VecSet<ID>): u64

9MoveLoc[0](Arg0: &RaffleRegistry)

10ImmBorrowField[0](RaffleRegistry.paused: bool)

11ReadRef

12Ret

}

public get_certificate_info(Arg0: &WinnerCertificate): ID * ID * address * u64 {

B0:

0CopyLoc[0](Arg0: &WinnerCertificate)

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

2CopyLoc[0](Arg0: &WinnerCertificate)

3ImmBorrowField[16](WinnerCertificate.raffle_id: ID)

4ReadRef

5CopyLoc[0](Arg0: &WinnerCertificate)

6ImmBorrowField[17](WinnerCertificate.winner: address)

7ReadRef

8MoveLoc[0](Arg0: &WinnerCertificate)

9ImmBorrowField[18](WinnerCertificate.winning_ticket: u64)

10ReadRef

11Ret

}

entry public claim_proceeds(Arg0: &Raffle, Arg1: &mut TicketManager, Arg2: &mut FeeManager, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: u64

L6: loc1: Coin<SUI>

L7: loc2: u64

L8: loc3: address

L9: loc4: Coin<SUI>

L10: loc5: u64

B0:

0CopyLoc[3](Arg3: &Clock)

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

2CopyLoc[0](Arg0: &Raffle)

3ImmBorrowField[4](Raffle.end_time: u64)

4ReadRef

5Ge

6BrFalse(8)

B1:

7Branch(20)

B2:

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

9Pop

10MoveLoc[0](Arg0: &Raffle)

11Pop

12MoveLoc[2](Arg2: &mut FeeManager)

13Pop

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

15Pop

16MoveLoc[3](Arg3: &Clock)

17Pop

18LdConst[2](u64: 3)

19Abort

B3:

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

21FreezeRef

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

23CopyLoc[0](Arg0: &Raffle)

24ImmBorrowField[11](Raffle.creator: address)

25ReadRef

26Eq

27BrFalse(29)

B4:

28Branch(41)

B5:

29MoveLoc[1](Arg1: &mut TicketManager)

30Pop

31MoveLoc[0](Arg0: &Raffle)

32Pop

33MoveLoc[2](Arg2: &mut FeeManager)

34Pop

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

36Pop

37MoveLoc[3](Arg3: &Clock)

38Pop

39LdConst[5](u64: 7)

40Abort

B6:

41CopyLoc[1](Arg1: &mut TicketManager)

42FreezeRef

43Call object::id<TicketManager>(&TicketManager): ID

44CopyLoc[0](Arg0: &Raffle)

45ImmBorrowField[5](Raffle.ticket_manager_id: ID)

46ReadRef

47Eq

48BrFalse(50)

B7:

49Branch(62)

B8:

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

51Pop

52MoveLoc[0](Arg0: &Raffle)

53Pop

54MoveLoc[2](Arg2: &mut FeeManager)

55Pop

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

57Pop

58MoveLoc[3](Arg3: &Clock)

59Pop

60LdConst[10](u64: 12)

61Abort

B9:

62CopyLoc[0](Arg0: &Raffle)

63ImmBorrowField[3](Raffle.is_active: bool)

64ReadRef

65Not

66BrFalse(68)

B10:

67Branch(80)

B11:

68MoveLoc[1](Arg1: &mut TicketManager)

69Pop

70MoveLoc[0](Arg0: &Raffle)

71Pop

72MoveLoc[2](Arg2: &mut FeeManager)

73Pop

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

75Pop

76MoveLoc[3](Arg3: &Clock)

77Pop

78LdConst[0](u64: 1)

79Abort

B12:

80CopyLoc[0](Arg0: &Raffle)

81ImmBorrowField[7](Raffle.winner: Option<address>)

82Call option::is_some<address>(&Option<address>): bool

83BrFalse(85)

B13:

84Branch(97)

B14:

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

86Pop

87MoveLoc[0](Arg0: &Raffle)

88Pop

89MoveLoc[2](Arg2: &mut FeeManager)

90Pop

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

92Pop

93MoveLoc[3](Arg3: &Clock)

94Pop

95LdConst[12](u64: 14)

96Abort

B15:

97MoveLoc[1](Arg1: &mut TicketManager)

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

99Call ticket_manager::extract_proceeds(&mut TicketManager, &mut TxContext): Coin<SUI>

100StLoc[9](loc4: Coin<SUI>)

101ImmBorrowLoc[9](loc4: Coin<SUI>)

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

103StLoc[10](loc5: u64)

104CopyLoc[2](Arg2: &mut FeeManager)

105MutBorrowLoc[9](loc4: Coin<SUI>)

106CopyLoc[0](Arg0: &Raffle)

107Call object::id<Raffle>(&Raffle): ID

108CopyLoc[3](Arg3: &Clock)

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

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

111Call fee_manager::take_percentage_fee(&mut FeeManager, &mut Coin<SUI>, ID, u64, &mut TxContext): Coin<SUI>

112StLoc[6](loc1: Coin<SUI>)

113ImmBorrowLoc[6](loc1: Coin<SUI>)

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

115StLoc[7](loc2: u64)

116ImmBorrowLoc[9](loc4: Coin<SUI>)

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

118StLoc[5](loc0: u64)

119MoveLoc[2](Arg2: &mut FeeManager)

120FreezeRef

121Call fee_manager::get_fee_settings(&FeeManager): u64 * u64 * address * bool

122Pop

123StLoc[8](loc3: address)

124Pop

125Pop

126MoveLoc[6](loc1: Coin<SUI>)

127MoveLoc[8](loc3: address)

128Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)

129MoveLoc[9](loc4: Coin<SUI>)

130CopyLoc[0](Arg0: &Raffle)

131ImmBorrowField[11](Raffle.creator: address)

132ReadRef

133Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)

134CopyLoc[0](Arg0: &Raffle)

135Call object::id<Raffle>(&Raffle): ID

136MoveLoc[0](Arg0: &Raffle)

137ImmBorrowField[11](Raffle.creator: address)

138ReadRef

139MoveLoc[10](loc5: u64)

140MoveLoc[7](loc2: u64)

141MoveLoc[5](loc0: u64)

142MoveLoc[3](Arg3: &Clock)

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

144Pack[10](ProceedsClaimed)

145Call event::emit<ProceedsClaimed>(ProceedsClaimed)

146Ret

}

Constants [

0 => u64: 1

1 => u64: 2

2 => u64: 3

3 => u64: 4

4 => u64: 5

5 => u64: 7

6 => u64: 8

7 => u64: 9

8 => u64: 10

9 => u64: 11

10 => u64: 12

11 => u64: 13

12 => u64: 14

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

14 => vector<u8>: "{name}" // interpreted as UTF8 string

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

16 => vector<u8>: "{description}" // interpreted as UTF8 string

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

18 => vector<u8>: "{image_url}" // interpreted as UTF8 string

19 => vector<u8>: "creator" // interpreted as UTF8 string

20 => vector<u8>: "{creator}" // interpreted as UTF8 string

21 => vector<u8>: "Raffle Winner Certificate" // interpreted as UTF8 string

22 => vector<u8>: "Certificate for winning raffle {raffle_id}" // interpreted as UTF8 string

23 => vector<u8>: "https://sui-raffles.io/winner-image/{raffle_id}" // interpreted as UTF8 string

24 => address: 0x0000000000000000000000000000000000000000000000000000000000000000

25 => vector<u8>: "NFT" // interpreted as UTF8 string

26 => vector<u8>: "KIOSK_NFT" // interpreted as UTF8 string

27 => vector<u8>: "TOKEN" // interpreted as UTF8 string

28 => vector<u8>: "Minimum tickets not met" // interpreted as UTF8 string

]

}