guild_v2

Module0x351d…0dc6

Move path: 0xe19a…dfe6::guild_v2
Functions: 1411 public, 0 entry
Structs: 11
Friend modules: None

guild_v2

Bytecode1221 lines

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

// Move bytecode v6

module e19a74728854cd996c7d26b8ced51ecbc2bb655ce33bb3976992b638fcb9dfe6.guild_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 GUILD has drop {

dummy_field: bool

}

struct GuildVault 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 RewardClaimedEvent has copy, drop {

token_type: TypeName,

owner: address,

guild_id: u128,

rw_id: u128,

amount: u64,

nonce: u128

}

struct CreateGuildEvent has copy, drop {

guild_id: u128,

creator: address,

nonce: u128

}

struct RenameGuildEvent has copy, drop {

guild_id: u128,

guild_name: String,

changer: address,

nonce: u128

}

struct UpdateGuildEvent has copy, drop {

guild_id: u128,

updater: address,

guild_level: u64,

nonce: u128

}

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

L2: loc0: GuildVault

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(24, 0)

8Pack[1](GuildVault)

9StLoc[2](loc0: GuildVault)

10ImmBorrowLoc[2](loc0: GuildVault)

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

12Pack[3](VaultCreatedEvent)

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

14MoveLoc[2](loc0: GuildVault)

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

16Ret

}

deposit_to_vault<Ty0>(Arg0: &mut GuildVault, 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 GuildVault)

1FreezeRef

2Call object::id<GuildVault>(&GuildVault): 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 GuildVault)

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

11CopyLoc[3](loc0: TypeName)

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

13Not

14BrFalse(20)

B1:

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

16MutBorrowField[0](GuildVault.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 GuildVault)

21MutBorrowField[0](GuildVault.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 GuildVault)

34CopyLoc[3](loc0: TypeName)

35CopyLoc[4](loc1: u64)

36LdU64(0)

37MoveLoc[2](Arg2: &Clock)

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

39MoveLoc[7](loc4: ID)

40MoveLoc[3](loc0: TypeName)

41MoveLoc[4](loc1: u64)

42MoveLoc[5](loc2: u64)

43Pack[5](VaultDepositEvent)

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

45Ret

}

withdraw_from_vault<Ty0>(Arg0: &mut GuildVault, 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 GuildVault)

1FreezeRef

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

3StLoc[8](loc4: ID)

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

5StLoc[4](loc0: TypeName)

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

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

8CopyLoc[4](loc0: TypeName)

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

10BrFalse(12)

B1:

11Branch(20)

B2:

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

13Pop

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

15Pop

16MoveLoc[2](Arg2: &Clock)

17Pop

18LdConst[11](u64: 6022)

19Abort

B3:

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

21MutBorrowField[0](GuildVault.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 GuildVault)

35Pop

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

37Pop

38MoveLoc[2](Arg2: &Clock)

39Pop

40LdConst[9](u64: 6016)

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 GuildVault)

51CopyLoc[4](loc0: TypeName)

52LdU64(0)

53CopyLoc[1](Arg1: u64)

54MoveLoc[2](Arg2: &Clock)

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

56MoveLoc[8](loc4: ID)

57MoveLoc[4](loc0: TypeName)

58MoveLoc[1](Arg1: u64)

59MoveLoc[5](loc1: u64)

60Pack[6](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 GuildVault, 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 GuildVault)

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

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

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

4FreezeRef

5VecLen(24)

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(24)

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[2](TokenStat)

63VecPushBack(24)

64Ret

}

public get_vault_balance<Ty0>(Arg0: &GuildVault): u64 {

L1: loc0: TypeName

B0:

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

1StLoc[1](loc0: TypeName)

2CopyLoc[0](Arg0: &GuildVault)

3ImmBorrowField[0](GuildVault.balances: Bag)

4CopyLoc[1](loc0: TypeName)

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

6Not

7BrFalse(12)

B1:

8MoveLoc[0](Arg0: &GuildVault)

9Pop

10LdU64(0)

11Ret

B2:

12MoveLoc[0](Arg0: &GuildVault)

13ImmBorrowField[0](GuildVault.balances: Bag)

14MoveLoc[1](loc0: TypeName)

15Call bag::borrow<TypeName, Balance<Ty0>>(&Bag, TypeName): &Balance<Ty0>

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

17Ret

}

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 create_guild<Ty0>(Arg0: &Config, Arg1: &mut GuildVault, Arg2: &mut UserArchive, Arg3: u128, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: Coin<Ty0>, Arg7: &Clock, Arg8: &mut TxContext) {

L9: loc0: &mut TxContext

L10: loc1: bool

L11: loc2: u64

L12: loc3: BCS

L13: loc4: String

L14: loc5: address

L15: loc6: u64

L16: loc7: u128

L17: loc8: u128

L18: loc9: u128

L19: loc10: u64

L20: loc11: address

L21: loc12: vector<u8>

L22: loc13: String

L23: loc14: u8

B0:

0CopyLoc[0](Arg0: &Config)

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

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

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

4MoveLoc[0](Arg0: &Config)

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

6CopyLoc[5](Arg5: vector<u8>)

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

8CopyLoc[8](Arg8: &mut TxContext)

9FreezeRef

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

11StLoc[20](loc11: address)

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

13MoveLoc[8](Arg8: &mut TxContext)

14StLoc[9](loc0: &mut TxContext)

15FreezeRef

16MoveLoc[9](loc0: &mut TxContext)

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

18CopyLoc[7](Arg7: &Clock)

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

20StLoc[19](loc10: u64)

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

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

23StLoc[12](loc3: BCS)

24MutBorrowLoc[12](loc3: BCS)

25Call bcs::peel_u8(&mut BCS): u8

26MutBorrowLoc[12](loc3: BCS)

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

28MutBorrowLoc[12](loc3: BCS)

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

30MutBorrowLoc[12](loc3: BCS)

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

32MutBorrowLoc[12](loc3: BCS)

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

34MutBorrowLoc[12](loc3: BCS)

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

36MutBorrowLoc[12](loc3: BCS)

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

38StLoc[18](loc9: u128)

39StLoc[15](loc6: u64)

40StLoc[21](loc12: vector<u8>)

41StLoc[11](loc2: u64)

42StLoc[16](loc7: u128)

43StLoc[14](loc5: address)

44StLoc[23](loc14: u8)

45CopyLoc[20](loc11: address)

46MoveLoc[14](loc5: address)

47Eq

48BrFalse(50)

B1:

49Branch(58)

B2:

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

51Pop

52MoveLoc[7](Arg7: &Clock)

53Pop

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

55Pop

56LdConst[5](u64: 6012)

57Abort

B3:

58CopyLoc[19](loc10: u64)

59MoveLoc[15](loc6: u64)

60Lt

61BrFalse(63)

B4:

62Branch(71)

B5:

63MoveLoc[1](Arg1: &mut GuildVault)

64Pop

65MoveLoc[7](Arg7: &Clock)

66Pop

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

68Pop

69LdConst[4](u64: 6003)

70Abort

B6:

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

72Call type_name::into_string(TypeName): String

73Call string::from_ascii(String): String

74StLoc[13](loc4: String)

75MoveLoc[21](loc12: vector<u8>)

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

77StLoc[22](loc13: String)

78MoveLoc[13](loc4: String)

79MoveLoc[22](loc13: String)

80Eq

81BrFalse(83)

B7:

82Branch(91)

B8:

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

84Pop

85MoveLoc[7](Arg7: &Clock)

86Pop

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

88Pop

89LdConst[3](u64: 6002)

90Abort

B9:

91MoveLoc[16](loc7: u128)

92CopyLoc[3](Arg3: u128)

93Eq

94BrFalse(96)

B10:

95Branch(104)

B11:

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

97Pop

98MoveLoc[7](Arg7: &Clock)

99Pop

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

101Pop

102LdConst[6](u64: 6013)

103Abort

B12:

104CopyLoc[11](loc2: u64)

105LdU64(0)

106Gt

107BrFalse(114)

B13:

108ImmBorrowLoc[6](Arg6: Coin<Ty0>)

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

110MoveLoc[11](loc2: u64)

111Eq

112StLoc[10](loc1: bool)

113Branch(116)

B14:

114LdFalse

115StLoc[10](loc1: bool)

B15:

116MoveLoc[10](loc1: bool)

117BrFalse(119)

B16:

118Branch(127)

B17:

119MoveLoc[1](Arg1: &mut GuildVault)

120Pop

121MoveLoc[7](Arg7: &Clock)

122Pop

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

124Pop

125LdConst[2](u64: 6001)

126Abort

B18:

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

128MoveLoc[23](loc14: u8)

129MoveLoc[18](loc9: u128)

130Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128

131StLoc[17](loc8: u128)

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

133MoveLoc[19](loc10: u64)

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

135MoveLoc[1](Arg1: &mut GuildVault)

136MoveLoc[6](Arg6: Coin<Ty0>)

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

138MoveLoc[7](Arg7: &Clock)

139Call deposit_to_vault<Ty0>(&mut GuildVault, Balance<Ty0>, &Clock)

140MoveLoc[3](Arg3: u128)

141MoveLoc[20](loc11: address)

142MoveLoc[17](loc8: u128)

143Pack[8](CreateGuildEvent)

144Call event::emit<CreateGuildEvent>(CreateGuildEvent)

145Ret

}

public rename_guild<Ty0>(Arg0: &Config, Arg1: &mut GuildVault, Arg2: &mut UserArchive, Arg3: u128, Arg4: String, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Coin<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {

L10: loc0: &mut TxContext

L11: loc1: bool

L12: loc2: u64

L13: loc3: BCS

L14: loc4: String

L15: loc5: address

L16: loc6: u64

L17: loc7: u128

L18: loc8: vector<u8>

L19: loc9: u128

L20: loc10: u128

L21: loc11: u64

L22: loc12: address

L23: loc13: vector<u8>

L24: loc14: String

L25: loc15: u8

B0:

0CopyLoc[0](Arg0: &Config)

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

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

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

4CopyLoc[0](Arg0: &Config)

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

6CopyLoc[6](Arg6: vector<u8>)

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

8CopyLoc[9](Arg9: &mut TxContext)

9FreezeRef

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

11StLoc[22](loc12: address)

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

13MoveLoc[9](Arg9: &mut TxContext)

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

15FreezeRef

16MoveLoc[10](loc0: &mut TxContext)

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

18CopyLoc[8](Arg8: &Clock)

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

20StLoc[21](loc11: u64)

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

22MoveLoc[0](Arg0: &Config)

23CopyLoc[8](Arg8: &Clock)

24Call guild::set_archive_change_name_time(&mut UserArchive, &Config, &Clock)

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

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

27StLoc[13](loc3: BCS)

28MutBorrowLoc[13](loc3: BCS)

29Call bcs::peel_u8(&mut BCS): u8

30MutBorrowLoc[13](loc3: BCS)

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

32MutBorrowLoc[13](loc3: BCS)

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

34MutBorrowLoc[13](loc3: BCS)

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

36MutBorrowLoc[13](loc3: BCS)

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

38MutBorrowLoc[13](loc3: BCS)

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

40MutBorrowLoc[13](loc3: BCS)

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

42MutBorrowLoc[13](loc3: BCS)

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

44StLoc[20](loc10: u128)

45StLoc[16](loc6: u64)

46StLoc[23](loc13: vector<u8>)

47StLoc[12](loc2: u64)

48StLoc[18](loc8: vector<u8>)

49StLoc[17](loc7: u128)

50StLoc[15](loc5: address)

51StLoc[25](loc15: u8)

52CopyLoc[22](loc12: address)

53MoveLoc[15](loc5: address)

54Eq

55BrFalse(57)

B1:

56Branch(65)

B2:

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

58Pop

59MoveLoc[8](Arg8: &Clock)

60Pop

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

62Pop

63LdConst[5](u64: 6012)

64Abort

B3:

65CopyLoc[21](loc11: u64)

66MoveLoc[16](loc6: u64)

67Lt

68BrFalse(70)

B4:

69Branch(78)

B5:

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

71Pop

72MoveLoc[8](Arg8: &Clock)

73Pop

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

75Pop

76LdConst[4](u64: 6003)

77Abort

B6:

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

79Call type_name::into_string(TypeName): String

80Call string::from_ascii(String): String

81StLoc[14](loc4: String)

82MoveLoc[23](loc13: vector<u8>)

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

84StLoc[24](loc14: String)

85MoveLoc[14](loc4: String)

86MoveLoc[24](loc14: String)

87Eq

88BrFalse(90)

B7:

89Branch(98)

B8:

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

91Pop

92MoveLoc[8](Arg8: &Clock)

93Pop

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

95Pop

96LdConst[3](u64: 6002)

97Abort

B9:

98MoveLoc[17](loc7: u128)

99CopyLoc[3](Arg3: u128)

100Eq

101BrFalse(103)

B10:

102Branch(111)

B11:

103MoveLoc[1](Arg1: &mut GuildVault)

104Pop

105MoveLoc[8](Arg8: &Clock)

106Pop

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

108Pop

109LdConst[6](u64: 6013)

110Abort

B12:

111CopyLoc[4](Arg4: String)

112MoveLoc[18](loc8: vector<u8>)

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

114Eq

115BrFalse(117)

B13:

116Branch(125)

B14:

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

118Pop

119MoveLoc[8](Arg8: &Clock)

120Pop

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

122Pop

123LdConst[10](u64: 6019)

124Abort

B15:

125CopyLoc[12](loc2: u64)

126LdU64(0)

127Gt

128BrFalse(135)

B16:

129ImmBorrowLoc[7](Arg7: Coin<Ty0>)

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

131MoveLoc[12](loc2: u64)

132Eq

133StLoc[11](loc1: bool)

134Branch(137)

B17:

135LdFalse

136StLoc[11](loc1: bool)

B18:

137MoveLoc[11](loc1: bool)

138BrFalse(140)

B19:

139Branch(148)

B20:

140MoveLoc[1](Arg1: &mut GuildVault)

141Pop

142MoveLoc[8](Arg8: &Clock)

143Pop

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

145Pop

146LdConst[2](u64: 6001)

147Abort

B21:

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

149MoveLoc[25](loc15: u8)

150MoveLoc[20](loc10: u128)

151Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128

152StLoc[19](loc9: u128)

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

154MoveLoc[21](loc11: u64)

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

156MoveLoc[1](Arg1: &mut GuildVault)

157MoveLoc[7](Arg7: Coin<Ty0>)

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

159MoveLoc[8](Arg8: &Clock)

160Call deposit_to_vault<Ty0>(&mut GuildVault, Balance<Ty0>, &Clock)

161MoveLoc[3](Arg3: u128)

162MoveLoc[4](Arg4: String)

163MoveLoc[22](loc12: address)

164MoveLoc[19](loc9: u128)

165Pack[9](RenameGuildEvent)

166Call event::emit<RenameGuildEvent>(RenameGuildEvent)

167Ret

}

public update_guild<Ty0>(Arg0: &Config, Arg1: &mut GuildVault, Arg2: &mut UserArchive, Arg3: u128, Arg4: u64, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Coin<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {

L10: loc0: &mut TxContext

L11: loc1: bool

L12: loc2: u64

L13: loc3: BCS

L14: loc4: String

L15: loc5: u64

L16: loc6: u128

L17: loc7: u64

L18: loc8: u128

L19: loc9: u128

L20: loc10: u64

L21: loc11: address

L22: loc12: vector<u8>

L23: loc13: String

L24: loc14: u8

L25: loc15: address

B0:

0CopyLoc[0](Arg0: &Config)

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

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

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

4MoveLoc[0](Arg0: &Config)

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

6CopyLoc[6](Arg6: vector<u8>)

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

8CopyLoc[9](Arg9: &mut TxContext)

9FreezeRef

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

11StLoc[21](loc11: address)

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

13MoveLoc[9](Arg9: &mut TxContext)

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

15FreezeRef

16MoveLoc[10](loc0: &mut TxContext)

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

18CopyLoc[8](Arg8: &Clock)

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

20StLoc[20](loc10: u64)

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

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

23StLoc[13](loc3: BCS)

24MutBorrowLoc[13](loc3: BCS)

25Call bcs::peel_u8(&mut BCS): u8

26MutBorrowLoc[13](loc3: BCS)

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

28MutBorrowLoc[13](loc3: BCS)

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

30MutBorrowLoc[13](loc3: BCS)

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

32MutBorrowLoc[13](loc3: BCS)

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

34MutBorrowLoc[13](loc3: BCS)

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

36MutBorrowLoc[13](loc3: BCS)

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

38MutBorrowLoc[13](loc3: BCS)

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

40StLoc[19](loc9: u128)

41StLoc[15](loc5: u64)

42StLoc[22](loc12: vector<u8>)

43StLoc[12](loc2: u64)

44StLoc[17](loc7: u64)

45StLoc[16](loc6: u128)

46StLoc[25](loc15: address)

47StLoc[24](loc14: u8)

48CopyLoc[21](loc11: address)

49MoveLoc[25](loc15: address)

50Eq

51BrFalse(53)

B1:

52Branch(61)

B2:

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

54Pop

55MoveLoc[8](Arg8: &Clock)

56Pop

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

58Pop

59LdConst[5](u64: 6012)

60Abort

B3:

61MoveLoc[20](loc10: u64)

62MoveLoc[15](loc5: u64)

63Lt

64BrFalse(66)

B4:

65Branch(74)

B5:

66MoveLoc[1](Arg1: &mut GuildVault)

67Pop

68MoveLoc[8](Arg8: &Clock)

69Pop

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

71Pop

72LdConst[4](u64: 6003)

73Abort

B6:

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

75Call type_name::into_string(TypeName): String

76Call string::from_ascii(String): String

77StLoc[14](loc4: String)

78MoveLoc[22](loc12: vector<u8>)

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

80StLoc[23](loc13: String)

81MoveLoc[14](loc4: String)

82MoveLoc[23](loc13: String)

83Eq

84BrFalse(86)

B7:

85Branch(94)

B8:

86MoveLoc[1](Arg1: &mut GuildVault)

87Pop

88MoveLoc[8](Arg8: &Clock)

89Pop

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

91Pop

92LdConst[3](u64: 6002)

93Abort

B9:

94MoveLoc[16](loc6: u128)

95CopyLoc[3](Arg3: u128)

96Eq

97BrFalse(99)

B10:

98Branch(107)

B11:

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

100Pop

101MoveLoc[8](Arg8: &Clock)

102Pop

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

104Pop

105LdConst[6](u64: 6013)

106Abort

B12:

107CopyLoc[4](Arg4: u64)

108MoveLoc[17](loc7: u64)

109Eq

110BrFalse(112)

B13:

111Branch(120)

B14:

112MoveLoc[1](Arg1: &mut GuildVault)

113Pop

114MoveLoc[8](Arg8: &Clock)

115Pop

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

117Pop

118LdConst[7](u64: 6014)

119Abort

B15:

120CopyLoc[12](loc2: u64)

121LdU64(0)

122Gt

123BrFalse(130)

B16:

124ImmBorrowLoc[7](Arg7: Coin<Ty0>)

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

126MoveLoc[12](loc2: u64)

127Eq

128StLoc[11](loc1: bool)

129Branch(132)

B17:

130LdFalse

131StLoc[11](loc1: bool)

B18:

132MoveLoc[11](loc1: bool)

133BrFalse(135)

B19:

134Branch(143)

B20:

135MoveLoc[1](Arg1: &mut GuildVault)

136Pop

137MoveLoc[8](Arg8: &Clock)

138Pop

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

140Pop

141LdConst[2](u64: 6001)

142Abort

B21:

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

144MoveLoc[24](loc14: u8)

145MoveLoc[19](loc9: u128)

146Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128

147StLoc[18](loc8: u128)

148MoveLoc[1](Arg1: &mut GuildVault)

149MoveLoc[7](Arg7: Coin<Ty0>)

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

151MoveLoc[8](Arg8: &Clock)

152Call deposit_to_vault<Ty0>(&mut GuildVault, Balance<Ty0>, &Clock)

153MoveLoc[3](Arg3: u128)

154MoveLoc[21](loc11: address)

155MoveLoc[4](Arg4: u64)

156MoveLoc[18](loc8: u128)

157Pack[10](UpdateGuildEvent)

158Call event::emit<UpdateGuildEvent>(UpdateGuildEvent)

159Ret

}

public claim_reward<Ty0>(Arg0: &Config, Arg1: &mut UserArchive, Arg2: &mut GuildVault, Arg3: u128, Arg4: u128, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: &Clock, Arg8: &mut TxContext) {

L9: loc0: &mut TxContext

L10: loc1: u64

L11: loc2: BCS

L12: loc3: Coin<Ty0>

L13: loc4: String

L14: loc5: u64

L15: loc6: u128

L16: loc7: u128

L17: loc8: u128

L18: loc9: u64

L19: loc10: address

L20: loc11: u128

L21: loc12: address

L22: loc13: vector<u8>

L23: loc14: String

L24: loc15: u8

B0:

0CopyLoc[0](Arg0: &Config)

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

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

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

4MoveLoc[0](Arg0: &Config)

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

6CopyLoc[6](Arg6: vector<u8>)

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

8CopyLoc[8](Arg8: &mut TxContext)

9FreezeRef

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

11StLoc[21](loc12: address)

12CopyLoc[1](Arg1: &mut UserArchive)

13CopyLoc[8](Arg8: &mut TxContext)

14StLoc[9](loc0: &mut TxContext)

15FreezeRef

16MoveLoc[9](loc0: &mut TxContext)

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

18CopyLoc[7](Arg7: &Clock)

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

20StLoc[18](loc9: u64)

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

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

23StLoc[11](loc2: BCS)

24MutBorrowLoc[11](loc2: BCS)

25Call bcs::peel_u8(&mut BCS): u8

26MutBorrowLoc[11](loc2: BCS)

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

28MutBorrowLoc[11](loc2: BCS)

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

30MutBorrowLoc[11](loc2: BCS)

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

32MutBorrowLoc[11](loc2: BCS)

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

34MutBorrowLoc[11](loc2: BCS)

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

36MutBorrowLoc[11](loc2: BCS)

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

38MutBorrowLoc[11](loc2: BCS)

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

40StLoc[17](loc8: u128)

41StLoc[14](loc5: u64)

42StLoc[10](loc1: u64)

43StLoc[22](loc13: vector<u8>)

44StLoc[20](loc11: u128)

45StLoc[15](loc6: u128)

46StLoc[19](loc10: address)

47StLoc[24](loc15: u8)

48CopyLoc[21](loc12: address)

49MoveLoc[19](loc10: address)

50Eq

51BrFalse(53)

B1:

52Branch(63)

B2:

53MoveLoc[2](Arg2: &mut GuildVault)

54Pop

55MoveLoc[8](Arg8: &mut TxContext)

56Pop

57MoveLoc[7](Arg7: &Clock)

58Pop

59MoveLoc[1](Arg1: &mut UserArchive)

60Pop

61LdConst[1](u64: 6000)

62Abort

B3:

63MoveLoc[18](loc9: u64)

64MoveLoc[14](loc5: u64)

65Lt

66BrFalse(68)

B4:

67Branch(78)

B5:

68MoveLoc[2](Arg2: &mut GuildVault)

69Pop

70MoveLoc[8](Arg8: &mut TxContext)

71Pop

72MoveLoc[7](Arg7: &Clock)

73Pop

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

75Pop

76LdConst[4](u64: 6003)

77Abort

B6:

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

79Call type_name::into_string(TypeName): String

80Call string::from_ascii(String): String

81StLoc[13](loc4: String)

82MoveLoc[22](loc13: vector<u8>)

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

84StLoc[23](loc14: String)

85MoveLoc[13](loc4: String)

86MoveLoc[23](loc14: String)

87Eq

88BrFalse(90)

B7:

89Branch(100)

B8:

90MoveLoc[2](Arg2: &mut GuildVault)

91Pop

92MoveLoc[8](Arg8: &mut TxContext)

93Pop

94MoveLoc[7](Arg7: &Clock)

95Pop

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

97Pop

98LdConst[3](u64: 6002)

99Abort

B9:

100MoveLoc[15](loc6: u128)

101CopyLoc[3](Arg3: u128)

102Eq

103BrFalse(105)

B10:

104Branch(115)

B11:

105MoveLoc[2](Arg2: &mut GuildVault)

106Pop

107MoveLoc[8](Arg8: &mut TxContext)

108Pop

109MoveLoc[7](Arg7: &Clock)

110Pop

111MoveLoc[1](Arg1: &mut UserArchive)

112Pop

113LdConst[6](u64: 6013)

114Abort

B12:

115MoveLoc[4](Arg4: u128)

116CopyLoc[20](loc11: u128)

117Eq

118BrFalse(120)

B13:

119Branch(130)

B14:

120MoveLoc[2](Arg2: &mut GuildVault)

121Pop

122MoveLoc[8](Arg8: &mut TxContext)

123Pop

124MoveLoc[7](Arg7: &Clock)

125Pop

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

127Pop

128LdConst[8](u64: 6015)

129Abort

B15:

130CopyLoc[10](loc1: u64)

131LdU64(0)

132Gt

133BrFalse(135)

B16:

134Branch(145)

B17:

135MoveLoc[2](Arg2: &mut GuildVault)

136Pop

137MoveLoc[8](Arg8: &mut TxContext)

138Pop

139MoveLoc[7](Arg7: &Clock)

140Pop

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

142Pop

143LdConst[2](u64: 6001)

144Abort

B18:

145CopyLoc[1](Arg1: &mut UserArchive)

146MoveLoc[24](loc15: u8)

147MoveLoc[17](loc8: u128)

148Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128

149StLoc[16](loc7: u128)

150MoveLoc[2](Arg2: &mut GuildVault)

151CopyLoc[10](loc1: u64)

152MoveLoc[7](Arg7: &Clock)

153MoveLoc[8](Arg8: &mut TxContext)

154Call withdraw_from_vault<Ty0>(&mut GuildVault, u64, &Clock, &mut TxContext): Coin<Ty0>

155StLoc[12](loc3: Coin<Ty0>)

156MoveLoc[1](Arg1: &mut UserArchive)

157CopyLoc[10](loc1: u64)

158Call guild::update_user_reward<Ty0>(&mut UserArchive, u64)

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

160CopyLoc[21](loc12: address)

161MoveLoc[3](Arg3: u128)

162MoveLoc[20](loc11: u128)

163MoveLoc[10](loc1: u64)

164MoveLoc[16](loc7: u128)

165Pack[7](RewardClaimedEvent)

166Call event::emit<RewardClaimedEvent>(RewardClaimedEvent)

167MoveLoc[12](loc3: Coin<Ty0>)

168MoveLoc[21](loc12: address)

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

170Ret

}

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

B0:

0CopyLoc[2](Arg2: address)

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

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

3WriteRef

4MoveLoc[2](Arg2: address)

5Pack[4](SetFundReceiverEvent)

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

7Ret

}

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

B0:

0MoveLoc[0](Arg0: &AdminCap)

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

2MoveLoc[2](Arg2: u64)

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

4Ret

}

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

B0:

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

1MoveLoc[2](Arg2: u64)

2MoveLoc[3](Arg3: &Clock)

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

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

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

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

7ReadRef

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

9Ret

}

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

B0:

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

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

2MoveLoc[3](Arg3: &Clock)

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

4Ret

}

Constants [

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

1 => u64: 6000

2 => u64: 6001

3 => u64: 6002

4 => u64: 6003

5 => u64: 6012

6 => u64: 6013

7 => u64: 6014

8 => u64: 6015

9 => u64: 6016

10 => u64: 6019

11 => u64: 6022

]

}