quest_v2

Module0x351d…0dc6

Move path: 0xe19a…dfe6::quest_v2
Functions: 1310 public, 0 entry
Structs: 9
Friend modules: None

quest_v2

Bytecode658 lines

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

// Move bytecode v6

module e19a74728854cd996c7d26b8ced51ecbc2bb655ce33bb3976992b638fcb9dfe6.quest_v2 {

use e19a74728854cd996c7d26b8ced51ecbc2bb655ce33bb3976992b638fcb9dfe6::guild;

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::bag;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::bcs;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct QuestVault has key {

id: UID,

balances: Bag,

fund_receiver: address,

tokens_stat: vector<TokenStat>

}

struct TokenStat has copy, drop, store {

token_type: TypeName,

amount_in: u64,

amount_out: u64,

last_updated: u64

}

struct VaultCreatedEvent has copy, drop {

vault_id: ID

}

struct SetFundReceiverEvent has copy, drop {

new_receiver: address

}

struct VaultDepositEvent has copy, drop {

vault_id: ID,

token_type: TypeName,

amount: u64,

total_balance: u64

}

struct VaultWithdrawEvent has copy, drop {

vault_id: ID,

token_type: TypeName,

amount: u64,

total_balance: u64

}

struct SetCheckinFeeEvent has copy, drop, store {

fee: u64,

type: TypeName

}

struct EventCheckin has copy, drop, store {

user: address,

day: u64,

last_checkin_time: u64

}

struct ClaimBonusEvent has copy, drop, store {

user: address,

task_id: String,

sub_task_id: String,

point: u128,

min_time: u64,

max_time: u64,

msg_expire_time: u64

}

public register(Arg0: &mut Logs, Arg1: &mut Config, Arg2: &mut TxContext): UserArchive {

B0:

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

1MoveLoc[1](Arg1: &mut Config)

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

3Call guild::register(&mut Logs, &mut Config, &mut TxContext): UserArchive

4Ret

}

public init_vault(Arg0: &AdminCap, Arg1: &mut TxContext) {

L2: loc0: QuestVault

B0:

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

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

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

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

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

5FreezeRef

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

7VecPack(21, 0)

8Pack[0](QuestVault)

9StLoc[2](loc0: QuestVault)

10ImmBorrowLoc[2](loc0: QuestVault)

11Call object::id<QuestVault>(&QuestVault): ID

12Pack[2](VaultCreatedEvent)

13Call event::emit<VaultCreatedEvent>(VaultCreatedEvent)

14MoveLoc[2](loc0: QuestVault)

15Call transfer::share_object<QuestVault>(QuestVault)

16Ret

}

public set_checkin_fee<Ty0>(Arg0: &AdminCap, Arg1: &mut Config, Arg2: u64) {

B0:

0CopyLoc[0](Arg0: &AdminCap)

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

2CopyLoc[2](Arg2: u64)

3Call guild::set_checkin_fee(&AdminCap, &mut Config, u64)

4MoveLoc[0](Arg0: &AdminCap)

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

6LdConst[0](vector<u8>: "QUE..)

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

8Call guild::set_fee_type<Ty0>(&AdminCap, &mut Config, String)

9MoveLoc[2](Arg2: u64)

10Call type_name::get<Ty0>(): TypeName

11Pack[6](SetCheckinFeeEvent)

12Call event::emit<SetCheckinFeeEvent>(SetCheckinFeeEvent)

13Ret

}

public checkin<Ty0>(Arg0: &Config, Arg1: &mut QuestVault, Arg2: &mut UserArchive, Arg3: Coin<Ty0>, Arg4: &Clock, Arg5: &mut TxContext) {

L6: loc0: &mut TxContext

L7: loc1: u64

L8: loc2: u64

L9: loc3: address

B0:

0CopyLoc[0](Arg0: &Config)

1LdConst[0](vector<u8>: "QUE..)

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

3Call guild::verify_config(&Config, String)

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

5FreezeRef

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

7StLoc[9](loc3: address)

8CopyLoc[2](Arg2: &mut UserArchive)

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

10StLoc[6](loc0: &mut TxContext)

11FreezeRef

12MoveLoc[6](loc0: &mut TxContext)

13Call guild::validate_archive_owner(&UserArchive, &mut TxContext)

14CopyLoc[2](Arg2: &mut UserArchive)

15Call guild::init_checkin(&mut UserArchive)

16CopyLoc[0](Arg0: &Config)

17LdConst[0](vector<u8>: "QUE..)

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

19Call guild::get_fee_type(&Config, String): TypeName

20Call type_name::get<Ty0>(): TypeName

21Eq

22BrFalse(24)

B1:

23Branch(34)

B2:

24MoveLoc[1](Arg1: &mut QuestVault)

25Pop

26MoveLoc[0](Arg0: &Config)

27Pop

28MoveLoc[4](Arg4: &Clock)

29Pop

30MoveLoc[2](Arg2: &mut UserArchive)

31Pop

32LdConst[5](u64: 8005)

33Abort

B3:

34ImmBorrowLoc[3](Arg3: Coin<Ty0>)

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

36CopyLoc[0](Arg0: &Config)

37Call guild::get_checkin_fee(&Config): u64

38Ge

39BrFalse(41)

B4:

40Branch(51)

B5:

41MoveLoc[1](Arg1: &mut QuestVault)

42Pop

43MoveLoc[0](Arg0: &Config)

44Pop

45MoveLoc[4](Arg4: &Clock)

46Pop

47MoveLoc[2](Arg2: &mut UserArchive)

48Pop

49LdConst[4](u64: 8004)

50Abort

B6:

51MoveLoc[0](Arg0: &Config)

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

53CopyLoc[4](Arg4: &Clock)

54Call guild::set_checkin(&Config, &mut UserArchive, &Clock): u64 * u64

55StLoc[8](loc2: u64)

56StLoc[7](loc1: u64)

57MoveLoc[1](Arg1: &mut QuestVault)

58MoveLoc[3](Arg3: Coin<Ty0>)

59Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>

60MoveLoc[4](Arg4: &Clock)

61Call deposit_to_vault<Ty0>(&mut QuestVault, Balance<Ty0>, &Clock)

62MoveLoc[9](loc3: address)

63MoveLoc[7](loc1: u64)

64MoveLoc[8](loc2: u64)

65Pack[7](EventCheckin)

66Call event::emit<EventCheckin>(EventCheckin)

67Ret

}

public claim_bonus_point<Ty0>(Arg0: &Config, Arg1: &mut QuestVault, Arg2: &mut UserArchive, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: Coin<Ty0>, Arg6: &Clock, Arg7: &mut TxContext) {

L8: loc0: &mut TxContext

L9: loc1: BCS

L10: loc2: address

L11: loc3: String

L12: loc4: u64

L13: loc5: u64

L14: loc6: vector<u8>

L15: loc7: u64

L16: loc8: u128

L17: loc9: address

L18: loc10: vector<u8>

L19: loc11: vector<u8>

L20: loc12: u64

L21: loc13: u64

L22: loc14: String

B0:

0CopyLoc[0](Arg0: &Config)

1LdConst[0](vector<u8>: "QUE..)

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

3Call guild::verify_config(&Config, String)

4CopyLoc[7](Arg7: &mut TxContext)

5FreezeRef

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

7StLoc[17](loc9: address)

8CopyLoc[2](Arg2: &mut UserArchive)

9MoveLoc[7](Arg7: &mut TxContext)

10StLoc[8](loc0: &mut TxContext)

11FreezeRef

12MoveLoc[8](loc0: &mut TxContext)

13Call guild::validate_archive_owner(&UserArchive, &mut TxContext)

14MoveLoc[0](Arg0: &Config)

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

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

17Call guild::verify_signature_v2(&Config, vector<u8>, vector<u8>)

18CopyLoc[6](Arg6: &Clock)

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

20StLoc[15](loc7: u64)

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

22Call bcs::new(vector<u8>): BCS

23StLoc[9](loc1: BCS)

24MutBorrowLoc[9](loc1: BCS)

25Call bcs::peel_address(&mut BCS): address

26MutBorrowLoc[9](loc1: BCS)

27Call bcs::peel_u128(&mut BCS): u128

28MutBorrowLoc[9](loc1: BCS)

29Call bcs::peel_u64(&mut BCS): u64

30MutBorrowLoc[9](loc1: BCS)

31Call bcs::peel_u64(&mut BCS): u64

32MutBorrowLoc[9](loc1: BCS)

33Call bcs::peel_u64(&mut BCS): u64

34MutBorrowLoc[9](loc1: BCS)

35Call bcs::peel_vec_u8(&mut BCS): vector<u8>

36MutBorrowLoc[9](loc1: BCS)

37Call bcs::peel_vec_u8(&mut BCS): vector<u8>

38MutBorrowLoc[9](loc1: BCS)

39Call bcs::peel_vec_u8(&mut BCS): vector<u8>

40MutBorrowLoc[9](loc1: BCS)

41Call bcs::peel_u64(&mut BCS): u64

42StLoc[12](loc4: u64)

43StLoc[18](loc10: vector<u8>)

44StLoc[19](loc11: vector<u8>)

45StLoc[14](loc6: vector<u8>)

46StLoc[20](loc12: u64)

47StLoc[21](loc13: u64)

48StLoc[13](loc5: u64)

49StLoc[16](loc8: u128)

50StLoc[10](loc2: address)

51CopyLoc[17](loc9: address)

52MoveLoc[10](loc2: address)

53Eq

54BrFalse(56)

B1:

55Branch(64)

B2:

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

57Pop

58MoveLoc[6](Arg6: &Clock)

59Pop

60MoveLoc[2](Arg2: &mut UserArchive)

61Pop

62LdConst[2](u64: 8002)

63Abort

B3:

64ImmBorrowLoc[5](Arg5: Coin<Ty0>)

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

66MoveLoc[13](loc5: u64)

67Eq

68BrFalse(70)

B4:

69Branch(78)

B5:

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

71Pop

72MoveLoc[6](Arg6: &Clock)

73Pop

74MoveLoc[2](Arg2: &mut UserArchive)

75Pop

76LdConst[4](u64: 8004)

77Abort

B6:

78Call type_name::get<Ty0>(): TypeName

79Call type_name::into_string(TypeName): String

80Call string::from_ascii(String): String

81StLoc[11](loc3: String)

82MoveLoc[14](loc6: vector<u8>)

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

84StLoc[22](loc14: String)

85MoveLoc[11](loc3: String)

86MoveLoc[22](loc14: String)

87Eq

88BrFalse(90)

B7:

89Branch(98)

B8:

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

91Pop

92MoveLoc[6](Arg6: &Clock)

93Pop

94MoveLoc[2](Arg2: &mut UserArchive)

95Pop

96LdConst[6](u64: 8006)

97Abort

B9:

98CopyLoc[2](Arg2: &mut UserArchive)

99LdConst[1](vector<u8>: "QUE..)

100CopyLoc[19](loc11: vector<u8>)

101CopyLoc[21](loc13: u64)

102CopyLoc[20](loc12: u64)

103Call guild::update_task_time_range(&mut UserArchive, vector<u8>, vector<u8>, u64, u64)

104CopyLoc[15](loc7: u64)

105CopyLoc[12](loc4: u64)

106Lt

107BrFalse(109)

B10:

108Branch(117)

B11:

109MoveLoc[1](Arg1: &mut QuestVault)

110Pop

111MoveLoc[6](Arg6: &Clock)

112Pop

113MoveLoc[2](Arg2: &mut UserArchive)

114Pop

115LdConst[3](u64: 8003)

116Abort

B12:

117MoveLoc[1](Arg1: &mut QuestVault)

118MoveLoc[5](Arg5: Coin<Ty0>)

119Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>

120MoveLoc[6](Arg6: &Clock)

121Call deposit_to_vault<Ty0>(&mut QuestVault, Balance<Ty0>, &Clock)

122MoveLoc[2](Arg2: &mut UserArchive)

123MoveLoc[15](loc7: u64)

124Call guild::set_archive_last_name_time(&mut UserArchive, u64)

125MoveLoc[17](loc9: address)

126MoveLoc[19](loc11: vector<u8>)

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

128MoveLoc[18](loc10: vector<u8>)

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

130MoveLoc[16](loc8: u128)

131MoveLoc[21](loc13: u64)

132MoveLoc[20](loc12: u64)

133MoveLoc[12](loc4: u64)

134Pack[8](ClaimBonusEvent)

135Call event::emit<ClaimBonusEvent>(ClaimBonusEvent)

136Ret

}

public set_max_check_in_days(Arg0: &AdminCap, Arg1: &mut Config, Arg2: u64) {

B0:

0MoveLoc[0](Arg0: &AdminCap)

1MoveLoc[1](Arg1: &mut Config)

2MoveLoc[2](Arg2: u64)

3Call guild::set_max_check_in_days(&AdminCap, &mut Config, u64)

4Ret

}

deposit_to_vault<Ty0>(Arg0: &mut QuestVault, Arg1: Balance<Ty0>, Arg2: &Clock) {

L3: loc0: TypeName

L4: loc1: u64

L5: loc2: u64

L6: loc3: &mut Balance<Ty0>

L7: loc4: ID

B0:

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

1FreezeRef

2Call object::id<QuestVault>(&QuestVault): ID

3StLoc[7](loc4: ID)

4Call type_name::get<Ty0>(): TypeName

5StLoc[3](loc0: TypeName)

6ImmBorrowLoc[1](Arg1: Balance<Ty0>)

7Call balance::value<Ty0>(&Balance<Ty0>): u64

8StLoc[4](loc1: u64)

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

10ImmBorrowField[0](QuestVault.balances: Bag)

11CopyLoc[3](loc0: TypeName)

12Call bag::contains<TypeName>(&Bag, TypeName): bool

13Not

14BrFalse(20)

B1:

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

16MutBorrowField[0](QuestVault.balances: Bag)

17CopyLoc[3](loc0: TypeName)

18Call balance::zero<Ty0>(): Balance<Ty0>

19Call bag::add<TypeName, Balance<Ty0>>(&mut Bag, TypeName, Balance<Ty0>)

B2:

20CopyLoc[0](Arg0: &mut QuestVault)

21MutBorrowField[0](QuestVault.balances: Bag)

22CopyLoc[3](loc0: TypeName)

23Call bag::borrow_mut<TypeName, Balance<Ty0>>(&mut Bag, TypeName): &mut Balance<Ty0>

24StLoc[6](loc3: &mut Balance<Ty0>)

25CopyLoc[6](loc3: &mut Balance<Ty0>)

26MoveLoc[1](Arg1: Balance<Ty0>)

27Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

28Pop

29MoveLoc[6](loc3: &mut Balance<Ty0>)

30FreezeRef

31Call balance::value<Ty0>(&Balance<Ty0>): u64

32StLoc[5](loc2: u64)

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

34CopyLoc[3](loc0: TypeName)

35CopyLoc[4](loc1: u64)

36LdU64(0)

37MoveLoc[2](Arg2: &Clock)

38Call update_vault_token_stat(&mut QuestVault, TypeName, u64, u64, &Clock)

39MoveLoc[7](loc4: ID)

40MoveLoc[3](loc0: TypeName)

41MoveLoc[4](loc1: u64)

42MoveLoc[5](loc2: u64)

43Pack[4](VaultDepositEvent)

44Call event::emit<VaultDepositEvent>(VaultDepositEvent)

45Ret

}

withdraw_from_vault<Ty0>(Arg0: &mut QuestVault, Arg1: u64, Arg2: &Clock, Arg3: &mut TxContext): Coin<Ty0> {

L4: loc0: TypeName

L5: loc1: u64

L6: loc2: Balance<Ty0>

L7: loc3: &mut Balance<Ty0>

L8: loc4: ID

B0:

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

1FreezeRef

2Call object::id<QuestVault>(&QuestVault): ID

3StLoc[8](loc4: ID)

4Call type_name::get<Ty0>(): TypeName

5StLoc[4](loc0: TypeName)

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

7ImmBorrowField[0](QuestVault.balances: Bag)

8CopyLoc[4](loc0: TypeName)

9Call bag::contains<TypeName>(&Bag, TypeName): bool

10BrFalse(12)

B1:

11Branch(20)

B2:

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

13Pop

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

15Pop

16MoveLoc[2](Arg2: &Clock)

17Pop

18LdConst[7](u64: 8007)

19Abort

B3:

20CopyLoc[0](Arg0: &mut QuestVault)

21MutBorrowField[0](QuestVault.balances: Bag)

22CopyLoc[4](loc0: TypeName)

23Call bag::borrow_mut<TypeName, Balance<Ty0>>(&mut Bag, TypeName): &mut Balance<Ty0>

24StLoc[7](loc3: &mut Balance<Ty0>)

25CopyLoc[7](loc3: &mut Balance<Ty0>)

26FreezeRef

27Call balance::value<Ty0>(&Balance<Ty0>): u64

28CopyLoc[1](Arg1: u64)

29Ge

30BrFalse(32)

B4:

31Branch(42)

B5:

32MoveLoc[7](loc3: &mut Balance<Ty0>)

33Pop

34MoveLoc[0](Arg0: &mut QuestVault)

35Pop

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

37Pop

38MoveLoc[2](Arg2: &Clock)

39Pop

40LdConst[8](u64: 8008)

41Abort

B6:

42CopyLoc[7](loc3: &mut Balance<Ty0>)

43CopyLoc[1](Arg1: u64)

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

45StLoc[6](loc2: Balance<Ty0>)

46MoveLoc[7](loc3: &mut Balance<Ty0>)

47FreezeRef

48Call balance::value<Ty0>(&Balance<Ty0>): u64

49StLoc[5](loc1: u64)

50MoveLoc[0](Arg0: &mut QuestVault)

51CopyLoc[4](loc0: TypeName)

52LdU64(0)

53CopyLoc[1](Arg1: u64)

54MoveLoc[2](Arg2: &Clock)

55Call update_vault_token_stat(&mut QuestVault, TypeName, u64, u64, &Clock)

56MoveLoc[8](loc4: ID)

57MoveLoc[4](loc0: TypeName)

58MoveLoc[1](Arg1: u64)

59MoveLoc[5](loc1: u64)

60Pack[5](VaultWithdrawEvent)

61Call event::emit<VaultWithdrawEvent>(VaultWithdrawEvent)

62MoveLoc[6](loc2: Balance<Ty0>)

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

64Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>

65Ret

}

update_vault_token_stat(Arg0: &mut QuestVault, Arg1: TypeName, Arg2: u64, Arg3: u64, Arg4: &Clock) {

L5: loc0: u64

L6: loc1: u64

L7: loc2: u64

L8: loc3: &mut TokenStat

L9: loc4: &mut vector<TokenStat>

B0:

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

1MutBorrowField[1](QuestVault.tokens_stat: vector<TokenStat>)

2StLoc[9](loc4: &mut vector<TokenStat>)

3CopyLoc[9](loc4: &mut vector<TokenStat>)

4FreezeRef

5VecLen(21)

6StLoc[6](loc1: u64)

7LdU64(0)

8StLoc[5](loc0: u64)

9MoveLoc[4](Arg4: &Clock)

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

11StLoc[7](loc2: u64)

B1:

12CopyLoc[5](loc0: u64)

13CopyLoc[6](loc1: u64)

14Lt

15BrFalse(57)

B2:

16Branch(17)

B3:

17CopyLoc[9](loc4: &mut vector<TokenStat>)

18CopyLoc[5](loc0: u64)

19VecMutBorrow(21)

20StLoc[8](loc3: &mut TokenStat)

21CopyLoc[8](loc3: &mut TokenStat)

22ImmBorrowField[2](TokenStat.token_type: TypeName)

23ReadRef

24CopyLoc[1](Arg1: TypeName)

25Eq

26BrFalse(50)

B4:

27MoveLoc[9](loc4: &mut vector<TokenStat>)

28Pop

29CopyLoc[8](loc3: &mut TokenStat)

30ImmBorrowField[3](TokenStat.amount_in: u64)

31ReadRef

32MoveLoc[2](Arg2: u64)

33Add

34CopyLoc[8](loc3: &mut TokenStat)

35MutBorrowField[3](TokenStat.amount_in: u64)

36WriteRef

37CopyLoc[8](loc3: &mut TokenStat)

38ImmBorrowField[4](TokenStat.amount_out: u64)

39ReadRef

40MoveLoc[3](Arg3: u64)

41Add

42CopyLoc[8](loc3: &mut TokenStat)

43MutBorrowField[4](TokenStat.amount_out: u64)

44WriteRef

45MoveLoc[7](loc2: u64)

46MoveLoc[8](loc3: &mut TokenStat)

47MutBorrowField[5](TokenStat.last_updated: u64)

48WriteRef

49Ret

B5:

50MoveLoc[8](loc3: &mut TokenStat)

51Pop

52MoveLoc[5](loc0: u64)

53LdU64(1)

54Add

55StLoc[5](loc0: u64)

56Branch(12)

B6:

57MoveLoc[9](loc4: &mut vector<TokenStat>)

58MoveLoc[1](Arg1: TypeName)

59MoveLoc[2](Arg2: u64)

60MoveLoc[3](Arg3: u64)

61MoveLoc[7](loc2: u64)

62Pack[1](TokenStat)

63VecPushBack(21)

64Ret

}

public set_fund_receiver(Arg0: &AdminCap, Arg1: &mut QuestVault, Arg2: address) {

B0:

0CopyLoc[2](Arg2: address)

1MoveLoc[1](Arg1: &mut QuestVault)

2MutBorrowField[6](QuestVault.fund_receiver: address)

3WriteRef

4MoveLoc[2](Arg2: address)

5Pack[3](SetFundReceiverEvent)

6Call event::emit<SetFundReceiverEvent>(SetFundReceiverEvent)

7Ret

}

public withdraw_amount_from_vault<Ty0>(Arg0: &TreasureCap, Arg1: &mut QuestVault, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext) {

B0:

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

1MoveLoc[2](Arg2: u64)

2MoveLoc[3](Arg3: &Clock)

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

4Call withdraw_from_vault<Ty0>(&mut QuestVault, u64, &Clock, &mut TxContext): Coin<Ty0>

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

6ImmBorrowField[6](QuestVault.fund_receiver: address)

7ReadRef

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

9Ret

}

public deposit_fund_to_vault<Ty0>(Arg0: &TreasureCap, Arg1: &mut QuestVault, Arg2: Balance<Ty0>, Arg3: &Clock) {

B0:

0MoveLoc[1](Arg1: &mut QuestVault)

1MoveLoc[2](Arg2: Balance<Ty0>)

2MoveLoc[3](Arg3: &Clock)

3Call deposit_to_vault<Ty0>(&mut QuestVault, Balance<Ty0>, &Clock)

4Ret

}

public paused(Arg0: &AdminCap, Arg1: &mut Config, Arg2: bool) {

B0:

0MoveLoc[0](Arg0: &AdminCap)

1MoveLoc[1](Arg1: &mut Config)

2LdConst[0](vector<u8>: "QUE..)

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

4MoveLoc[2](Arg2: bool)

5Call guild::paused_v2(&AdminCap, &mut Config, String, bool)

6Ret

}

Constants [

0 => vector<u8>: "QUEST_MODULE" // interpreted as UTF8 string

1 => vector<u8>: "QUEST_CLAIM_BONUS_POINT_TIME_RANGE" // interpreted as UTF8 string

2 => u64: 8002

3 => u64: 8003

4 => u64: 8004

5 => u64: 8005

6 => u64: 8006

7 => u64: 8007

8 => u64: 8008

]

}