pool_factory

Module0x8925…bce5

Move path: 0x91bf…9ca1::pool_factory
Functions: 2117 public, 16 entry
Structs: 6
Friend modules: None

pool_factory

Bytecode1339 lines

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

// Move bytecode v6

module 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1.pool_factory {

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::hash;

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::acl;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::fee;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::partner;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::position_manager;

use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::position_nft;

struct PoolFactoryAdminCap has store, key {

id: UID

}

struct PoolSimpleInfo has copy, store {

pool_id: ID,

pool_key: ID,

coin_type_a: TypeName,

coin_type_b: TypeName,

fee_type: TypeName,

fee: u32,

tick_spacing: u32

}

struct PoolConfig has store, key {

id: UID,

fee_map: VecMap<String, ID>,

fee_protocol: u32,

pools: Table<ID, PoolSimpleInfo>

}

struct AclConfig has store, key {

id: UID,

acl: ACL

}

struct PoolCreatedEvent has copy, drop {

account: address,

pool: ID,

fee: u32,

tick_spacing: u32,

fee_protocol: u32,

sqrt_price: u128

}

struct FeeAmountEnabledEvent has copy, drop {

fee: u32,

tick_spacing: u32

}

struct SetFeeProtocolEvent has copy, drop {

fee_protocol: u32

}

struct SetRolesEvent has copy, drop {

member: address,

roles: u128

}

struct AddRoleEvent has copy, drop {

member: address,

role: u8

}

struct RemoveRoleEvent has copy, drop {

member: address,

role: u8

}

struct RemoveMemberEvent has copy, drop {

member: address

}

init(Arg0: &mut TxContext) {

B0:

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

1Call init_(&mut TxContext)

2Ret

}

init_(Arg0: &mut TxContext) {

B0:

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

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

2Call vec_map::empty<String, ID>(): VecMap<String, ID>

3LdU32(0)

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

5Call table::new<ID, PoolSimpleInfo>(&mut TxContext): Table<ID, PoolSimpleInfo>

6Pack[2](PoolConfig)

7Call transfer::share_object<PoolConfig>(PoolConfig)

8CopyLoc[0](Arg0: &mut TxContext)

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

10Pack[0](PoolFactoryAdminCap)

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

12FreezeRef

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

14Call transfer::transfer<PoolFactoryAdminCap>(PoolFactoryAdminCap, address)

15Ret

}

entry public deploy_pool_and_mint<Ty0, Ty1, Ty2>(Arg0: &mut PoolConfig, Arg1: &Fee<Ty2>, Arg2: u128, Arg3: &mut Positions, Arg4: vector<Coin<Ty0>>, Arg5: vector<Coin<Ty1>>, Arg6: u32, Arg7: bool, Arg8: u32, Arg9: bool, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u64, Arg14: address, Arg15: u64, Arg16: &Clock, Arg17: &Versioned, Arg18: &mut TxContext) {

L19: loc0: TypeName

L20: loc1: TypeName

L21: loc2: u32

L22: loc3: TypeName

L23: loc4: String

L24: loc5: Pool<Ty0, Ty1, Ty2>

L25: loc6: ID

L26: loc7: u32

B0:

0CopyLoc[17](Arg17: &Versioned)

1Call pool::check_version(&Versioned)

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

3StLoc[19](loc0: TypeName)

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

5StLoc[20](loc1: TypeName)

6CopyLoc[19](loc0: TypeName)

7CopyLoc[20](loc1: TypeName)

8Neq

9BrFalse(11)

B1:

10Branch(25)

B2:

11MoveLoc[17](Arg17: &Versioned)

12Pop

13MoveLoc[3](Arg3: &mut Positions)

14Pop

15MoveLoc[0](Arg0: &mut PoolConfig)

16Pop

17MoveLoc[1](Arg1: &Fee<Ty2>)

18Pop

19MoveLoc[18](Arg18: &mut TxContext)

20Pop

21MoveLoc[16](Arg16: &Clock)

22Pop

23LdConst[4](u64: 4)

24Abort

B3:

25Call type_name::get<Ty2>(): TypeName

26StLoc[22](loc3: TypeName)

27CopyLoc[22](loc3: TypeName)

28Call type_name::into_string(TypeName): String

29Call string::from_ascii(String): String

30StLoc[23](loc4: String)

31CopyLoc[0](Arg0: &mut PoolConfig)

32ImmBorrowField[0](PoolConfig.fee_map: VecMap<String, ID>)

33ImmBorrowLoc[23](loc4: String)

34Call vec_map::contains<String, ID>(&VecMap<String, ID>, &String): bool

35BrFalse(37)

B4:

36Branch(51)

B5:

37MoveLoc[17](Arg17: &Versioned)

38Pop

39MoveLoc[3](Arg3: &mut Positions)

40Pop

41MoveLoc[0](Arg0: &mut PoolConfig)

42Pop

43MoveLoc[1](Arg1: &Fee<Ty2>)

44Pop

45MoveLoc[18](Arg18: &mut TxContext)

46Pop

47MoveLoc[16](Arg16: &Clock)

48Pop

49LdConst[0](u64: 0)

50Abort

B6:

51CopyLoc[19](loc0: TypeName)

52CopyLoc[20](loc1: TypeName)

53CopyLoc[22](loc3: TypeName)

54Call pool_key<Ty0, Ty1, Ty2>(TypeName, TypeName, TypeName): ID

55StLoc[25](loc6: ID)

56CopyLoc[0](Arg0: &mut PoolConfig)

57ImmBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

58CopyLoc[25](loc6: ID)

59Call table::contains<ID, PoolSimpleInfo>(&Table<ID, PoolSimpleInfo>, ID): bool

60Not

61BrFalse(63)

B7:

62Branch(77)

B8:

63MoveLoc[17](Arg17: &Versioned)

64Pop

65MoveLoc[3](Arg3: &mut Positions)

66Pop

67MoveLoc[0](Arg0: &mut PoolConfig)

68Pop

69MoveLoc[1](Arg1: &Fee<Ty2>)

70Pop

71MoveLoc[18](Arg18: &mut TxContext)

72Pop

73MoveLoc[16](Arg16: &Clock)

74Pop

75LdConst[5](u64: 5)

76Abort

B9:

77CopyLoc[1](Arg1: &Fee<Ty2>)

78Call fee::get_fee<Ty2>(&Fee<Ty2>): u32

79StLoc[21](loc2: u32)

80MoveLoc[1](Arg1: &Fee<Ty2>)

81Call fee::get_tick_spacing<Ty2>(&Fee<Ty2>): u32

82StLoc[26](loc7: u32)

83CopyLoc[21](loc2: u32)

84CopyLoc[26](loc7: u32)

85CopyLoc[2](Arg2: u128)

86CopyLoc[0](Arg0: &mut PoolConfig)

87ImmBorrowField[2](PoolConfig.fee_protocol: u32)

88ReadRef

89CopyLoc[16](Arg16: &Clock)

90CopyLoc[18](Arg18: &mut TxContext)

91Call pool::deploy_pool<Ty0, Ty1, Ty2>(u32, u32, u128, u32, &Clock, &mut TxContext): Pool<Ty0, Ty1, Ty2>

92StLoc[24](loc5: Pool<Ty0, Ty1, Ty2>)

93CopyLoc[18](Arg18: &mut TxContext)

94FreezeRef

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

96ImmBorrowLoc[24](loc5: Pool<Ty0, Ty1, Ty2>)

97Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

98CopyLoc[21](loc2: u32)

99CopyLoc[26](loc7: u32)

100CopyLoc[0](Arg0: &mut PoolConfig)

101ImmBorrowField[2](PoolConfig.fee_protocol: u32)

102ReadRef

103MoveLoc[2](Arg2: u128)

104Pack[4](PoolCreatedEvent)

105Call event::emit<PoolCreatedEvent>(PoolCreatedEvent)

106MutBorrowLoc[24](loc5: Pool<Ty0, Ty1, Ty2>)

107MoveLoc[3](Arg3: &mut Positions)

108MoveLoc[4](Arg4: vector<Coin<Ty0>>)

109MoveLoc[5](Arg5: vector<Coin<Ty1>>)

110MoveLoc[6](Arg6: u32)

111MoveLoc[7](Arg7: bool)

112MoveLoc[8](Arg8: u32)

113MoveLoc[9](Arg9: bool)

114MoveLoc[10](Arg10: u64)

115MoveLoc[11](Arg11: u64)

116MoveLoc[12](Arg12: u64)

117MoveLoc[13](Arg13: u64)

118MoveLoc[14](Arg14: address)

119MoveLoc[15](Arg15: u64)

120MoveLoc[16](Arg16: &Clock)

121MoveLoc[17](Arg17: &Versioned)

122MoveLoc[18](Arg18: &mut TxContext)

123Call position_manager::mint<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, vector<Coin<Ty0>>, vector<Coin<Ty1>>, u32, bool, u32, bool, u64, u64, u64, u64, address, u64, &Clock, &Versioned, &mut TxContext)

124MoveLoc[0](Arg0: &mut PoolConfig)

125MutBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

126CopyLoc[25](loc6: ID)

127ImmBorrowLoc[24](loc5: Pool<Ty0, Ty1, Ty2>)

128Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

129MoveLoc[25](loc6: ID)

130MoveLoc[19](loc0: TypeName)

131MoveLoc[20](loc1: TypeName)

132MoveLoc[22](loc3: TypeName)

133MoveLoc[21](loc2: u32)

134MoveLoc[26](loc7: u32)

135Pack[1](PoolSimpleInfo)

136Call table::add<ID, PoolSimpleInfo>(&mut Table<ID, PoolSimpleInfo>, ID, PoolSimpleInfo)

137MoveLoc[24](loc5: Pool<Ty0, Ty1, Ty2>)

138Call transfer::public_share_object<Pool<Ty0, Ty1, Ty2>>(Pool<Ty0, Ty1, Ty2>)

139Ret

}

public deploy_pool_and_mint_with_return_<Ty0, Ty1, Ty2>(Arg0: &mut PoolConfig, Arg1: &Fee<Ty2>, Arg2: u128, Arg3: &mut Positions, Arg4: vector<Coin<Ty0>>, Arg5: vector<Coin<Ty1>>, Arg6: u32, Arg7: bool, Arg8: u32, Arg9: bool, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u64, Arg14: u64, Arg15: &Clock, Arg16: &Versioned, Arg17: &mut TxContext): TurbosPositionNFT * Coin<Ty0> * Coin<Ty1> * ID {

L18: loc0: Coin<Ty0>

L19: loc1: Coin<Ty1>

L20: loc2: TypeName

L21: loc3: TypeName

L22: loc4: u32

L23: loc5: TypeName

L24: loc6: String

L25: loc7: TurbosPositionNFT

L26: loc8: Pool<Ty0, Ty1, Ty2>

L27: loc9: ID

L28: loc10: ID

L29: loc11: u32

B0:

0CopyLoc[16](Arg16: &Versioned)

1Call pool::check_version(&Versioned)

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

3StLoc[20](loc2: TypeName)

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

5StLoc[21](loc3: TypeName)

6CopyLoc[20](loc2: TypeName)

7CopyLoc[21](loc3: TypeName)

8Neq

9BrFalse(11)

B1:

10Branch(25)

B2:

11MoveLoc[16](Arg16: &Versioned)

12Pop

13MoveLoc[3](Arg3: &mut Positions)

14Pop

15MoveLoc[0](Arg0: &mut PoolConfig)

16Pop

17MoveLoc[1](Arg1: &Fee<Ty2>)

18Pop

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

20Pop

21MoveLoc[15](Arg15: &Clock)

22Pop

23LdConst[4](u64: 4)

24Abort

B3:

25Call type_name::get<Ty2>(): TypeName

26StLoc[23](loc5: TypeName)

27CopyLoc[23](loc5: TypeName)

28Call type_name::into_string(TypeName): String

29Call string::from_ascii(String): String

30StLoc[24](loc6: String)

31CopyLoc[0](Arg0: &mut PoolConfig)

32ImmBorrowField[0](PoolConfig.fee_map: VecMap<String, ID>)

33ImmBorrowLoc[24](loc6: String)

34Call vec_map::contains<String, ID>(&VecMap<String, ID>, &String): bool

35BrFalse(37)

B4:

36Branch(51)

B5:

37MoveLoc[16](Arg16: &Versioned)

38Pop

39MoveLoc[3](Arg3: &mut Positions)

40Pop

41MoveLoc[0](Arg0: &mut PoolConfig)

42Pop

43MoveLoc[1](Arg1: &Fee<Ty2>)

44Pop

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

46Pop

47MoveLoc[15](Arg15: &Clock)

48Pop

49LdConst[0](u64: 0)

50Abort

B6:

51CopyLoc[20](loc2: TypeName)

52CopyLoc[21](loc3: TypeName)

53CopyLoc[23](loc5: TypeName)

54Call pool_key<Ty0, Ty1, Ty2>(TypeName, TypeName, TypeName): ID

55StLoc[28](loc10: ID)

56CopyLoc[0](Arg0: &mut PoolConfig)

57ImmBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

58CopyLoc[28](loc10: ID)

59Call table::contains<ID, PoolSimpleInfo>(&Table<ID, PoolSimpleInfo>, ID): bool

60Not

61BrFalse(63)

B7:

62Branch(77)

B8:

63MoveLoc[16](Arg16: &Versioned)

64Pop

65MoveLoc[3](Arg3: &mut Positions)

66Pop

67MoveLoc[0](Arg0: &mut PoolConfig)

68Pop

69MoveLoc[1](Arg1: &Fee<Ty2>)

70Pop

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

72Pop

73MoveLoc[15](Arg15: &Clock)

74Pop

75LdConst[5](u64: 5)

76Abort

B9:

77CopyLoc[1](Arg1: &Fee<Ty2>)

78Call fee::get_fee<Ty2>(&Fee<Ty2>): u32

79StLoc[22](loc4: u32)

80MoveLoc[1](Arg1: &Fee<Ty2>)

81Call fee::get_tick_spacing<Ty2>(&Fee<Ty2>): u32

82StLoc[29](loc11: u32)

83CopyLoc[22](loc4: u32)

84CopyLoc[29](loc11: u32)

85CopyLoc[2](Arg2: u128)

86CopyLoc[0](Arg0: &mut PoolConfig)

87ImmBorrowField[2](PoolConfig.fee_protocol: u32)

88ReadRef

89CopyLoc[15](Arg15: &Clock)

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

91Call pool::deploy_pool<Ty0, Ty1, Ty2>(u32, u32, u128, u32, &Clock, &mut TxContext): Pool<Ty0, Ty1, Ty2>

92StLoc[26](loc8: Pool<Ty0, Ty1, Ty2>)

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

94FreezeRef

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

96ImmBorrowLoc[26](loc8: Pool<Ty0, Ty1, Ty2>)

97Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

98CopyLoc[22](loc4: u32)

99CopyLoc[29](loc11: u32)

100CopyLoc[0](Arg0: &mut PoolConfig)

101ImmBorrowField[2](PoolConfig.fee_protocol: u32)

102ReadRef

103MoveLoc[2](Arg2: u128)

104Pack[4](PoolCreatedEvent)

105Call event::emit<PoolCreatedEvent>(PoolCreatedEvent)

106MutBorrowLoc[26](loc8: Pool<Ty0, Ty1, Ty2>)

107MoveLoc[3](Arg3: &mut Positions)

108MoveLoc[4](Arg4: vector<Coin<Ty0>>)

109MoveLoc[5](Arg5: vector<Coin<Ty1>>)

110MoveLoc[6](Arg6: u32)

111MoveLoc[7](Arg7: bool)

112MoveLoc[8](Arg8: u32)

113MoveLoc[9](Arg9: bool)

114MoveLoc[10](Arg10: u64)

115MoveLoc[11](Arg11: u64)

116MoveLoc[12](Arg12: u64)

117MoveLoc[13](Arg13: u64)

118MoveLoc[14](Arg14: u64)

119MoveLoc[15](Arg15: &Clock)

120MoveLoc[16](Arg16: &Versioned)

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

122Call position_manager::mint_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut Positions, vector<Coin<Ty0>>, vector<Coin<Ty1>>, u32, bool, u32, bool, u64, u64, u64, u64, u64, &Clock, &Versioned, &mut TxContext): TurbosPositionNFT * Coin<Ty0> * Coin<Ty1>

123StLoc[19](loc1: Coin<Ty1>)

124StLoc[18](loc0: Coin<Ty0>)

125StLoc[25](loc7: TurbosPositionNFT)

126ImmBorrowLoc[26](loc8: Pool<Ty0, Ty1, Ty2>)

127Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

128StLoc[27](loc9: ID)

129MoveLoc[0](Arg0: &mut PoolConfig)

130MutBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

131CopyLoc[28](loc10: ID)

132CopyLoc[27](loc9: ID)

133MoveLoc[28](loc10: ID)

134MoveLoc[20](loc2: TypeName)

135MoveLoc[21](loc3: TypeName)

136MoveLoc[23](loc5: TypeName)

137MoveLoc[22](loc4: u32)

138MoveLoc[29](loc11: u32)

139Pack[1](PoolSimpleInfo)

140Call table::add<ID, PoolSimpleInfo>(&mut Table<ID, PoolSimpleInfo>, ID, PoolSimpleInfo)

141MoveLoc[26](loc8: Pool<Ty0, Ty1, Ty2>)

142Call transfer::public_share_object<Pool<Ty0, Ty1, Ty2>>(Pool<Ty0, Ty1, Ty2>)

143MoveLoc[25](loc7: TurbosPositionNFT)

144MoveLoc[18](loc0: Coin<Ty0>)

145MoveLoc[19](loc1: Coin<Ty1>)

146MoveLoc[27](loc9: ID)

147Ret

}

entry public deploy_pool<Ty0, Ty1, Ty2>(Arg0: &mut PoolConfig, Arg1: &Fee<Ty2>, Arg2: u128, Arg3: &Clock, Arg4: &Versioned, Arg5: &mut TxContext) {

L6: loc0: TypeName

L7: loc1: TypeName

L8: loc2: u32

L9: loc3: TypeName

L10: loc4: String

L11: loc5: Pool<Ty0, Ty1, Ty2>

L12: loc6: ID

L13: loc7: u32

B0:

0MoveLoc[4](Arg4: &Versioned)

1Call pool::check_version(&Versioned)

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

3StLoc[6](loc0: TypeName)

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

5StLoc[7](loc1: TypeName)

6CopyLoc[6](loc0: TypeName)

7CopyLoc[7](loc1: TypeName)

8Neq

9BrFalse(11)

B1:

10Branch(21)

B2:

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

12Pop

13MoveLoc[1](Arg1: &Fee<Ty2>)

14Pop

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

16Pop

17MoveLoc[3](Arg3: &Clock)

18Pop

19LdConst[4](u64: 4)

20Abort

B3:

21Call type_name::get<Ty2>(): TypeName

22StLoc[9](loc3: TypeName)

23CopyLoc[9](loc3: TypeName)

24Call type_name::into_string(TypeName): String

25Call string::from_ascii(String): String

26StLoc[10](loc4: String)

27CopyLoc[0](Arg0: &mut PoolConfig)

28ImmBorrowField[0](PoolConfig.fee_map: VecMap<String, ID>)

29ImmBorrowLoc[10](loc4: String)

30Call vec_map::contains<String, ID>(&VecMap<String, ID>, &String): bool

31BrFalse(33)

B4:

32Branch(43)

B5:

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

34Pop

35MoveLoc[1](Arg1: &Fee<Ty2>)

36Pop

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

38Pop

39MoveLoc[3](Arg3: &Clock)

40Pop

41LdConst[0](u64: 0)

42Abort

B6:

43CopyLoc[6](loc0: TypeName)

44CopyLoc[7](loc1: TypeName)

45CopyLoc[9](loc3: TypeName)

46Call pool_key<Ty0, Ty1, Ty2>(TypeName, TypeName, TypeName): ID

47StLoc[12](loc6: ID)

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

49ImmBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

50CopyLoc[12](loc6: ID)

51Call table::contains<ID, PoolSimpleInfo>(&Table<ID, PoolSimpleInfo>, ID): bool

52Not

53BrFalse(55)

B7:

54Branch(65)

B8:

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

56Pop

57MoveLoc[1](Arg1: &Fee<Ty2>)

58Pop

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

60Pop

61MoveLoc[3](Arg3: &Clock)

62Pop

63LdConst[5](u64: 5)

64Abort

B9:

65CopyLoc[1](Arg1: &Fee<Ty2>)

66Call fee::get_fee<Ty2>(&Fee<Ty2>): u32

67StLoc[8](loc2: u32)

68MoveLoc[1](Arg1: &Fee<Ty2>)

69Call fee::get_tick_spacing<Ty2>(&Fee<Ty2>): u32

70StLoc[13](loc7: u32)

71CopyLoc[8](loc2: u32)

72CopyLoc[13](loc7: u32)

73CopyLoc[2](Arg2: u128)

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

75ImmBorrowField[2](PoolConfig.fee_protocol: u32)

76ReadRef

77MoveLoc[3](Arg3: &Clock)

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

79Call pool::deploy_pool<Ty0, Ty1, Ty2>(u32, u32, u128, u32, &Clock, &mut TxContext): Pool<Ty0, Ty1, Ty2>

80StLoc[11](loc5: Pool<Ty0, Ty1, Ty2>)

81CopyLoc[0](Arg0: &mut PoolConfig)

82MutBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

83CopyLoc[12](loc6: ID)

84ImmBorrowLoc[11](loc5: Pool<Ty0, Ty1, Ty2>)

85Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

86MoveLoc[12](loc6: ID)

87MoveLoc[6](loc0: TypeName)

88MoveLoc[7](loc1: TypeName)

89MoveLoc[9](loc3: TypeName)

90CopyLoc[8](loc2: u32)

91CopyLoc[13](loc7: u32)

92Pack[1](PoolSimpleInfo)

93Call table::add<ID, PoolSimpleInfo>(&mut Table<ID, PoolSimpleInfo>, ID, PoolSimpleInfo)

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

95FreezeRef

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

97ImmBorrowLoc[11](loc5: Pool<Ty0, Ty1, Ty2>)

98Call object::id<Pool<Ty0, Ty1, Ty2>>(&Pool<Ty0, Ty1, Ty2>): ID

99MoveLoc[8](loc2: u32)

100MoveLoc[13](loc7: u32)

101MoveLoc[0](Arg0: &mut PoolConfig)

102ImmBorrowField[2](PoolConfig.fee_protocol: u32)

103ReadRef

104MoveLoc[2](Arg2: u128)

105Pack[4](PoolCreatedEvent)

106Call event::emit<PoolCreatedEvent>(PoolCreatedEvent)

107MoveLoc[11](loc5: Pool<Ty0, Ty1, Ty2>)

108Call transfer::public_share_object<Pool<Ty0, Ty1, Ty2>>(Pool<Ty0, Ty1, Ty2>)

109Ret

}

public get_pool_id<Ty0, Ty1, Ty2>(Arg0: &mut PoolConfig): Option<ID> {

L1: loc0: Option<ID>

L2: loc1: TypeName

L3: loc2: TypeName

L4: loc3: TypeName

L5: loc4: ID

B0:

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

1StLoc[2](loc1: TypeName)

2Call type_name::get<Ty1>(): TypeName

3StLoc[3](loc2: TypeName)

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

5StLoc[4](loc3: TypeName)

6MoveLoc[2](loc1: TypeName)

7MoveLoc[3](loc2: TypeName)

8MoveLoc[4](loc3: TypeName)

9Call pool_key<Ty0, Ty1, Ty2>(TypeName, TypeName, TypeName): ID

10StLoc[5](loc4: ID)

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

12ImmBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

13CopyLoc[5](loc4: ID)

14Call table::contains<ID, PoolSimpleInfo>(&Table<ID, PoolSimpleInfo>, ID): bool

15BrFalse(25)

B1:

16MoveLoc[0](Arg0: &mut PoolConfig)

17ImmBorrowField[1](PoolConfig.pools: Table<ID, PoolSimpleInfo>)

18MoveLoc[5](loc4: ID)

19Call table::borrow<ID, PoolSimpleInfo>(&Table<ID, PoolSimpleInfo>, ID): &PoolSimpleInfo

20ImmBorrowField[3](PoolSimpleInfo.pool_id: ID)

21ReadRef

22Call option::some<ID>(ID): Option<ID>

23StLoc[1](loc0: Option<ID>)

24Branch(29)

B2:

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

26Pop

27Call option::none<ID>(): Option<ID>

28StLoc[1](loc0: Option<ID>)

B3:

29MoveLoc[1](loc0: Option<ID>)

30Ret

}

pool_key<Ty0, Ty1, Ty2>(Arg0: TypeName, Arg1: TypeName, Arg2: TypeName): ID {

L3: loc0: vector<u8>

L4: loc1: vector<u8>

L5: loc2: vector<u8>

L6: loc3: vector<u8>

L7: loc4: vector<u8>

L8: loc5: vector<u8>

L9: loc6: vector<u8>

B0:

0VecPack(76, 0)

1StLoc[9](loc6: vector<u8>)

2MoveLoc[0](Arg0: TypeName)

3Call type_name::into_string(TypeName): String

4Call ascii::into_bytes(String): vector<u8>

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

6MoveLoc[1](Arg1: TypeName)

7Call type_name::into_string(TypeName): String

8Call ascii::into_bytes(String): vector<u8>

9StLoc[7](loc4: vector<u8>)

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

11ImmBorrowLoc[7](loc4: vector<u8>)

12Call compare_types(&vector<u8>, &vector<u8>): bool

13Not

14BrFalse(20)

B1:

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

16MoveLoc[7](loc4: vector<u8>)

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

18StLoc[3](loc0: vector<u8>)

19Branch(24)

B2:

20MoveLoc[7](loc4: vector<u8>)

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

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

23StLoc[3](loc0: vector<u8>)

B3:

24MoveLoc[3](loc0: vector<u8>)

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

26StLoc[8](loc5: vector<u8>)

27StLoc[6](loc3: vector<u8>)

28MutBorrowLoc[9](loc6: vector<u8>)

29MoveLoc[6](loc3: vector<u8>)

30Call vector::append<u8>(&mut vector<u8>, vector<u8>)

31MutBorrowLoc[9](loc6: vector<u8>)

32MoveLoc[8](loc5: vector<u8>)

33Call vector::append<u8>(&mut vector<u8>, vector<u8>)

34MutBorrowLoc[9](loc6: vector<u8>)

35MoveLoc[2](Arg2: TypeName)

36Call type_name::into_string(TypeName): String

37Call ascii::into_bytes(String): vector<u8>

38Call vector::append<u8>(&mut vector<u8>, vector<u8>)

39MoveLoc[9](loc6: vector<u8>)

40Call hash::sha2_256(vector<u8>): vector<u8>

41Call object::id_from_bytes(vector<u8>): ID

42Ret

}

compare_types(Arg0: &vector<u8>, Arg1: &vector<u8>): bool {

L2: loc0: bool

L3: loc1: bool

L4: loc2: u64

L5: loc3: u8

L6: loc4: u64

L7: loc5: u8

L8: loc6: u64

B0:

0CopyLoc[0](Arg0: &vector<u8>)

1VecLen(76)

2StLoc[4](loc2: u64)

3CopyLoc[1](Arg1: &vector<u8>)

4VecLen(76)

5StLoc[6](loc4: u64)

6LdU64(0)

7StLoc[8](loc6: u64)

B1:

8CopyLoc[8](loc6: u64)

9CopyLoc[4](loc2: u64)

10Lt

11BrFalse(18)

B2:

12Branch(13)

B3:

13CopyLoc[8](loc6: u64)

14CopyLoc[6](loc4: u64)

15Lt

16StLoc[2](loc0: bool)

17Branch(20)

B4:

18LdFalse

19StLoc[2](loc0: bool)

B5:

20MoveLoc[2](loc0: bool)

21BrFalse(57)

B6:

22CopyLoc[0](Arg0: &vector<u8>)

23CopyLoc[8](loc6: u64)

24VecImmBorrow(76)

25ReadRef

26StLoc[5](loc3: u8)

27CopyLoc[1](Arg1: &vector<u8>)

28CopyLoc[8](loc6: u64)

29VecImmBorrow(76)

30ReadRef

31StLoc[7](loc5: u8)

32CopyLoc[5](loc3: u8)

33CopyLoc[7](loc5: u8)

34Lt

35BrFalse(42)

B7:

36MoveLoc[1](Arg1: &vector<u8>)

37Pop

38MoveLoc[0](Arg0: &vector<u8>)

39Pop

40LdFalse

41Ret

B8:

42MoveLoc[5](loc3: u8)

43MoveLoc[7](loc5: u8)

44Gt

45BrFalse(52)

B9:

46MoveLoc[1](Arg1: &vector<u8>)

47Pop

48MoveLoc[0](Arg0: &vector<u8>)

49Pop

50LdTrue

51Ret

B10:

52MoveLoc[8](loc6: u64)

53LdU64(1)

54Add

55StLoc[8](loc6: u64)

56Branch(8)

B11:

57MoveLoc[1](Arg1: &vector<u8>)

58Pop

59MoveLoc[0](Arg0: &vector<u8>)

60Pop

61MoveLoc[4](loc2: u64)

62MoveLoc[6](loc4: u64)

63Lt

64BrFalse(68)

B12:

65LdFalse

66StLoc[3](loc1: bool)

67Branch(70)

B13:

68LdTrue

69StLoc[3](loc1: bool)

B14:

70MoveLoc[3](loc1: bool)

71Ret

}

entry public set_fee_tier<Ty0>(Arg0: &PoolFactoryAdminCap, Arg1: &mut PoolConfig, Arg2: &Fee<Ty0>, Arg3: &Versioned) {

B0:

0LdU64(0)

1Abort

}

entry public set_fee_tier_v2<Ty0>(Arg0: &AclConfig, Arg1: &mut PoolConfig, Arg2: &Fee<Ty0>, Arg3: &Versioned, Arg4: &mut TxContext) {

L5: loc0: bool

L6: loc1: u32

L7: loc2: u32

L8: loc3: String

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_clmm_manager_role(&AclConfig, address)

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

8Call type_name::into_string(TypeName): String

9Call string::from_ascii(String): String

10StLoc[8](loc3: String)

11CopyLoc[1](Arg1: &mut PoolConfig)

12ImmBorrowField[0](PoolConfig.fee_map: VecMap<String, ID>)

13ImmBorrowLoc[8](loc3: String)

14Call vec_map::contains<String, ID>(&VecMap<String, ID>, &String): bool

15Not

16BrFalse(18)

B1:

17Branch(24)

B2:

18MoveLoc[1](Arg1: &mut PoolConfig)

19Pop

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

21Pop

22LdConst[3](u64: 3)

23Abort

B3:

24CopyLoc[2](Arg2: &Fee<Ty0>)

25Call fee::get_fee<Ty0>(&Fee<Ty0>): u32

26StLoc[6](loc1: u32)

27CopyLoc[2](Arg2: &Fee<Ty0>)

28Call fee::get_tick_spacing<Ty0>(&Fee<Ty0>): u32

29StLoc[7](loc2: u32)

30CopyLoc[6](loc1: u32)

31LdU32(1000000)

32Lt

33BrFalse(35)

B4:

34Branch(41)

B5:

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

36Pop

37MoveLoc[2](Arg2: &Fee<Ty0>)

38Pop

39LdConst[1](u64: 1)

40Abort

B6:

41CopyLoc[7](loc2: u32)

42LdU32(0)

43Gt

44BrFalse(50)

B7:

45CopyLoc[7](loc2: u32)

46LdU32(16384)

47Lt

48StLoc[5](loc0: bool)

49Branch(52)

B8:

50LdFalse

51StLoc[5](loc0: bool)

B9:

52MoveLoc[5](loc0: bool)

53BrFalse(55)

B10:

54Branch(61)

B11:

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

56Pop

57MoveLoc[2](Arg2: &Fee<Ty0>)

58Pop

59LdConst[2](u64: 2)

60Abort

B12:

61MoveLoc[1](Arg1: &mut PoolConfig)

62MutBorrowField[0](PoolConfig.fee_map: VecMap<String, ID>)

63MoveLoc[8](loc3: String)

64MoveLoc[2](Arg2: &Fee<Ty0>)

65Call object::id<Fee<Ty0>>(&Fee<Ty0>): ID

66Call vec_map::insert<String, ID>(&mut VecMap<String, ID>, String, ID)

67MoveLoc[6](loc1: u32)

68MoveLoc[7](loc2: u32)

69Pack[5](FeeAmountEnabledEvent)

70Call event::emit<FeeAmountEnabledEvent>(FeeAmountEnabledEvent)

71Ret

}

entry public set_fee_protocol(Arg0: &PoolFactoryAdminCap, Arg1: &mut PoolConfig, Arg2: u32, Arg3: &Versioned) {

B0:

0LdU64(0)

1Abort

}

entry public set_fee_protocol_v2(Arg0: &AclConfig, Arg1: &mut PoolConfig, Arg2: u32, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_clmm_manager_role(&AclConfig, address)

7CopyLoc[2](Arg2: u32)

8LdU32(1000000)

9Lt

10BrFalse(12)

B1:

11Branch(16)

B2:

12MoveLoc[1](Arg1: &mut PoolConfig)

13Pop

14LdConst[1](u64: 1)

15Abort

B3:

16CopyLoc[2](Arg2: u32)

17MoveLoc[1](Arg1: &mut PoolConfig)

18MutBorrowField[2](PoolConfig.fee_protocol: u32)

19WriteRef

20MoveLoc[2](Arg2: u32)

21Pack[6](SetFeeProtocolEvent)

22Call event::emit<SetFeeProtocolEvent>(SetFeeProtocolEvent)

23Ret

}

entry public update_pool_fee_protocol<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u32, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public update_pool_fee_protocol_v2<Ty0, Ty1, Ty2>(Arg0: &AclConfig, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u32, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_clmm_manager_role(&AclConfig, address)

7CopyLoc[2](Arg2: u32)

8LdU32(1000000)

9Lt

10BrFalse(12)

B1:

11Branch(16)

B2:

12MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1, Ty2>)

13Pop

14LdConst[1](u64: 1)

15Abort

B3:

16MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1, Ty2>)

17CopyLoc[2](Arg2: u32)

18Call pool::update_pool_fee_protocol<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u32)

19MoveLoc[2](Arg2: u32)

20Pack[6](SetFeeProtocolEvent)

21Call event::emit<SetFeeProtocolEvent>(SetFeeProtocolEvent)

22Ret

}

entry public collect_protocol_fee<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &Versioned, Arg6: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public collect_protocol_fee_v2<Ty0, Ty1, Ty2>(Arg0: &AclConfig, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &Versioned, Arg6: &mut TxContext) {

L7: loc0: Coin<Ty1>

B0:

0MoveLoc[5](Arg5: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_claim_protocol_fee_manager_role(&AclConfig, address)

7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1, Ty2>)

8MoveLoc[2](Arg2: u64)

9MoveLoc[3](Arg3: u64)

10CopyLoc[4](Arg4: address)

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

12Call pool::collect_protocol_fee_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64, u64, address, &mut TxContext): Coin<Ty0> * Coin<Ty1>

13StLoc[7](loc0: Coin<Ty1>)

14CopyLoc[4](Arg4: address)

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

16MoveLoc[7](loc0: Coin<Ty1>)

17MoveLoc[4](Arg4: address)

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

19Ret

}

public collect_protocol_fee_with_return_<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &Versioned, Arg6: &mut TxContext): Coin<Ty0> * Coin<Ty1> {

B0:

0LdU64(0)

1Abort

}

public collect_protocol_fee_with_return_v2<Ty0, Ty1, Ty2>(Arg0: &AclConfig, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u64, Arg3: u64, Arg4: address, Arg5: &Versioned, Arg6: &mut TxContext): Coin<Ty0> * Coin<Ty1> {

B0:

0MoveLoc[5](Arg5: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_claim_protocol_fee_manager_role(&AclConfig, address)

7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1, Ty2>)

8MoveLoc[2](Arg2: u64)

9MoveLoc[3](Arg3: u64)

10MoveLoc[4](Arg4: address)

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

12Call pool::collect_protocol_fee_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, u64, u64, address, &mut TxContext): Coin<Ty0> * Coin<Ty1>

13Ret

}

entry public toggle_pool_status<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: &Versioned, Arg3: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public toggle_pool_status_v2<Ty0, Ty1, Ty2>(Arg0: &AclConfig, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: &Versioned, Arg3: &mut TxContext) {

B0:

0MoveLoc[2](Arg2: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_pause_pool_manager_role(&AclConfig, address)

7MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1, Ty2>)

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

9Call pool::toggle_pool_status<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, &mut TxContext)

10Ret

}

entry public update_nft_name(Arg0: &PoolFactoryAdminCap, Arg1: &mut Positions, Arg2: String, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public update_nft_name_v2(Arg0: &AclConfig, Arg1: &mut Positions, Arg2: String, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_clmm_manager_role(&AclConfig, address)

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

8MoveLoc[2](Arg2: String)

9Call position_manager::update_nft_name(&mut Positions, String)

10Ret

}

entry public upgrade(Arg0: &PoolFactoryAdminCap, Arg1: &mut Versioned) {

B0:

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

1Call pool::upgrade(&mut Versioned)

2Ret

}

entry public update_nft_description(Arg0: &PoolFactoryAdminCap, Arg1: &mut Positions, Arg2: String, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public update_nft_description_v2(Arg0: &AclConfig, Arg1: &mut Positions, Arg2: String, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_clmm_manager_role(&AclConfig, address)

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

8MoveLoc[2](Arg2: String)

9Call position_manager::update_nft_description(&mut Positions, String)

10Ret

}

entry public update_nft_img_url(Arg0: &PoolFactoryAdminCap, Arg1: &mut Positions, Arg2: String, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public update_nft_img_url_v2(Arg0: &AclConfig, Arg1: &mut Positions, Arg2: String, Arg3: &Versioned, Arg4: &mut TxContext) {

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[0](Arg0: &AclConfig)

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

4FreezeRef

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

6Call check_clmm_manager_role(&AclConfig, address)

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

8MoveLoc[2](Arg2: String)

9Call position_manager::update_nft_img_url(&mut Positions, String)

10Ret

}

entry public migrate_position<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: &mut Positions, Arg3: vector<address>, Arg4: address, Arg5: &Versioned, Arg6: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public decrease_liquidity_admin<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: &mut Positions, Arg3: address, Arg4: u32, Arg5: bool, Arg6: u32, Arg7: bool, Arg8: address, Arg9: &Clock, Arg10: &Versioned, Arg11: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public modify_tick_reward<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u32, Arg3: bool, Arg4: &Clock, Arg5: &Versioned, Arg6: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public modify_tick<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: u32, Arg3: bool, Arg4: &Versioned) {

B0:

0LdU64(0)

1Abort

}

entry public modify_reward<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: &mut Positions, Arg3: u32, Arg4: bool, Arg5: u32, Arg6: bool, Arg7: vector<address>, Arg8: vector<address>, Arg9: &Versioned, Arg10: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public fake_swap<Ty0, Ty1, Ty2>(Arg0: &PoolFactoryAdminCap, Arg1: &mut Pool<Ty0, Ty1, Ty2>, Arg2: address, Arg3: bool, Arg4: u128, Arg5: bool, Arg6: u128, Arg7: &Clock, Arg8: &Versioned, Arg9: &mut TxContext) {

B0:

0LdU64(0)

1Abort

}

entry public init_partners(Arg0: &PoolFactoryAdminCap, Arg1: &mut TxContext) {

B0:

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

1Call partner::init_partners(&mut TxContext)

2Ret

}

entry public init_acl_config(Arg0: &PoolFactoryAdminCap, Arg1: &mut TxContext) {

L2: loc0: AclConfig

L3: loc1: address

L4: loc2: u128

B0:

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

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

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

3Call acl::new(&mut TxContext): ACL

4Pack[3](AclConfig)

5StLoc[2](loc0: AclConfig)

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

7FreezeRef

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

9StLoc[3](loc1: address)

10LdU128(1)

11LdConst[10](u8: 0)

12Shl

13LdU128(1)

14LdConst[11](u8: 1)

15Shl

16BitOr

17LdU128(1)

18LdConst[12](u8: 2)

19Shl

20BitOr

21LdU128(1)

22LdConst[13](u8: 3)

23Shl

24BitOr

25StLoc[4](loc2: u128)

26MutBorrowLoc[2](loc0: AclConfig)

27MutBorrowField[4](AclConfig.acl: ACL)

28MoveLoc[3](loc1: address)

29MoveLoc[4](loc2: u128)

30Call acl::set_roles(&mut ACL, address, u128)

31MoveLoc[2](loc0: AclConfig)

32Call transfer::share_object<AclConfig>(AclConfig)

33Ret

}

public acl(Arg0: &AclConfig): &ACL {

B0:

0MoveLoc[0](Arg0: &AclConfig)

1ImmBorrowField[4](AclConfig.acl: ACL)

2Ret

}

public add_role(Arg0: &PoolFactoryAdminCap, Arg1: &mut AclConfig, Arg2: address, Arg3: u8, Arg4: &Versioned) {

B0:

0MoveLoc[4](Arg4: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[1](Arg1: &mut AclConfig)

3MutBorrowField[4](AclConfig.acl: ACL)

4CopyLoc[2](Arg2: address)

5CopyLoc[3](Arg3: u8)

6Call acl::add_role(&mut ACL, address, u8)

7MoveLoc[2](Arg2: address)

8MoveLoc[3](Arg3: u8)

9Pack[8](AddRoleEvent)

10Call event::emit<AddRoleEvent>(AddRoleEvent)

11Ret

}

public get_members(Arg0: &AclConfig): vector<Member> {

B0:

0MoveLoc[0](Arg0: &AclConfig)

1ImmBorrowField[4](AclConfig.acl: ACL)

2Call acl::get_members(&ACL): vector<Member>

3Ret

}

public remove_member(Arg0: &PoolFactoryAdminCap, Arg1: &mut AclConfig, Arg2: address, Arg3: &Versioned) {

B0:

0MoveLoc[3](Arg3: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[1](Arg1: &mut AclConfig)

3MutBorrowField[4](AclConfig.acl: ACL)

4CopyLoc[2](Arg2: address)

5Call acl::remove_member(&mut ACL, address)

6MoveLoc[2](Arg2: address)

7Pack[10](RemoveMemberEvent)

8Call event::emit<RemoveMemberEvent>(RemoveMemberEvent)

9Ret

}

public remove_role(Arg0: &PoolFactoryAdminCap, Arg1: &mut AclConfig, Arg2: address, Arg3: u8, Arg4: &Versioned) {

B0:

0MoveLoc[4](Arg4: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[1](Arg1: &mut AclConfig)

3MutBorrowField[4](AclConfig.acl: ACL)

4CopyLoc[2](Arg2: address)

5CopyLoc[3](Arg3: u8)

6Call acl::remove_role(&mut ACL, address, u8)

7MoveLoc[2](Arg2: address)

8MoveLoc[3](Arg3: u8)

9Pack[9](RemoveRoleEvent)

10Call event::emit<RemoveRoleEvent>(RemoveRoleEvent)

11Ret

}

public set_roles(Arg0: &PoolFactoryAdminCap, Arg1: &mut AclConfig, Arg2: address, Arg3: u128, Arg4: &Versioned) {

B0:

0MoveLoc[4](Arg4: &Versioned)

1Call pool::check_version(&Versioned)

2MoveLoc[1](Arg1: &mut AclConfig)

3MutBorrowField[4](AclConfig.acl: ACL)

4CopyLoc[2](Arg2: address)

5CopyLoc[3](Arg3: u128)

6Call acl::set_roles(&mut ACL, address, u128)

7MoveLoc[2](Arg2: address)

8MoveLoc[3](Arg3: u128)

9Pack[7](SetRolesEvent)

10Call event::emit<SetRolesEvent>(SetRolesEvent)

11Ret

}

public check_clmm_manager_role(Arg0: &AclConfig, Arg1: address) {

B0:

0MoveLoc[0](Arg0: &AclConfig)

1ImmBorrowField[4](AclConfig.acl: ACL)

2MoveLoc[1](Arg1: address)

3LdConst[10](u8: 0)

4Call acl::has_role(&ACL, address, u8): bool

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[6](u64: 6)

8Abort

B3:

9Ret

}

public check_reward_manager_role(Arg0: &AclConfig, Arg1: address) {

B0:

0MoveLoc[0](Arg0: &AclConfig)

1ImmBorrowField[4](AclConfig.acl: ACL)

2MoveLoc[1](Arg1: address)

3LdConst[11](u8: 1)

4Call acl::has_role(&ACL, address, u8): bool

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[7](u64: 7)

8Abort

B3:

9Ret

}

public check_claim_protocol_fee_manager_role(Arg0: &AclConfig, Arg1: address) {

B0:

0MoveLoc[0](Arg0: &AclConfig)

1ImmBorrowField[4](AclConfig.acl: ACL)

2MoveLoc[1](Arg1: address)

3LdConst[12](u8: 2)

4Call acl::has_role(&ACL, address, u8): bool

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[8](u64: 8)

8Abort

B3:

9Ret

}

public check_pause_pool_manager_role(Arg0: &AclConfig, Arg1: address) {

B0:

0MoveLoc[0](Arg0: &AclConfig)

1ImmBorrowField[4](AclConfig.acl: ACL)

2MoveLoc[1](Arg1: address)

3LdConst[13](u8: 3)

4Call acl::has_role(&ACL, address, u8): bool

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[9](u64: 9)

8Abort

B3:

9Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

4 => u64: 4

5 => u64: 5

6 => u64: 6

7 => u64: 7

8 => u64: 8

9 => u64: 9

10 => u8: 0

11 => u8: 1

12 => u8: 2

13 => u8: 3

]

}