lb_factory

Module0x01ac…6d5c

Move path: 0x5a5c…83ac::lb_factory
Functions: 98 public, 0 entry
Structs: 4
Friend modules: None

lb_factory

Bytecode493 lines

The on-chain disassembly. Offsets are instruction numbers within each function.

// Move bytecode v6

module 5a5c1d10e4782dbbdec3eb8327ede04bd078b294b97cfdba447b11b846b383ac.lb_factory {

use 5a5c1d10e4782dbbdec3eb8327ede04bd078b294b97cfdba447b11b846b383ac::config;

use 5a5c1d10e4782dbbdec3eb8327ede04bd078b294b97cfdba447b11b846b383ac::lb_pair;

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::bcs;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::hash;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct PairSimpleInfo has copy, drop, store {

pair_id: ID,

pair_key: ID,

bin_step: u16,

coin_type_a: TypeName,

coin_type_b: TypeName

}

struct Pairs has store, key {

id: UID,

list: Table<ID, PairSimpleInfo>,

index: u64

}

struct InitFactoryEvent has copy, drop {

pair_factory: ID

}

struct CreatePairEvent has copy, drop {

pair_id: ID,

bin_step: u16,

coin_type_a: String,

coin_type_b: String,

active_id: u32

}

init(Arg0: &mut TxContext) {

L1: loc0: UID

L2: loc1: Table<ID, PairSimpleInfo>

L3: loc2: ID

L4: loc3: Pairs

B0:

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

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

2StLoc[1](loc0: UID)

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

4Call table::new<ID, PairSimpleInfo>(&mut TxContext): Table<ID, PairSimpleInfo>

5StLoc[2](loc1: Table<ID, PairSimpleInfo>)

6MoveLoc[1](loc0: UID)

7MoveLoc[2](loc1: Table<ID, PairSimpleInfo>)

8LdU64(0)

9Pack[1](Pairs)

10StLoc[4](loc3: Pairs)

11ImmBorrowLoc[4](loc3: Pairs)

12Call object::id<Pairs>(&Pairs): ID

13StLoc[3](loc2: ID)

14MoveLoc[4](loc3: Pairs)

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

16MoveLoc[3](loc2: ID)

17Pack[2](InitFactoryEvent)

18Call event::emit<InitFactoryEvent>(InitFactoryEvent)

19Ret

}

public create_pair<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pairs, Arg2: u32, Arg3: u16, Arg4: &mut TxContext) {

L5: loc0: bool

L6: loc1: bool

L7: loc2: ID

L8: loc3: String

L9: loc4: String

L10: loc5: u16

L11: loc6: u32

L12: loc7: TypeName

L13: loc8: TypeName

L14: loc9: LBPair<Ty0, Ty1>

L15: loc10: u32

L16: loc11: u32

L17: loc12: ID

L18: loc13: PairSimpleInfo

L19: loc14: ID

B0:

0CopyLoc[0](Arg0: &GlobalConfig)

1Call config::checked_package_version(&GlobalConfig)

2CopyLoc[0](Arg0: &GlobalConfig)

3Call config::global_paused(&GlobalConfig): bool

4Not

5BrFalse(7)

B1:

6Branch(15)

B2:

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

8Pop

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

10Pop

11MoveLoc[0](Arg0: &GlobalConfig)

12Pop

13LdConst[0](u64: 100)

14Abort

B3:

15CopyLoc[0](Arg0: &GlobalConfig)

16CopyLoc[3](Arg3: u16)

17Call config::bin_step_exists(&GlobalConfig, u16): bool

18BrFalse(20)

B4:

19Branch(28)

B5:

20MoveLoc[1](Arg1: &mut Pairs)

21Pop

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

23Pop

24MoveLoc[0](Arg0: &GlobalConfig)

25Pop

26LdConst[1](u64: 101)

27Abort

B6:

28CopyLoc[0](Arg0: &GlobalConfig)

29CopyLoc[3](Arg3: u16)

30Call config::get_bin_range(&GlobalConfig, u16): u32 * u32

31StLoc[15](loc10: u32)

32StLoc[16](loc11: u32)

33CopyLoc[2](Arg2: u32)

34MoveLoc[16](loc11: u32)

35Ge

36BrFalse(42)

B7:

37CopyLoc[2](Arg2: u32)

38MoveLoc[15](loc10: u32)

39Le

40StLoc[5](loc0: bool)

41Branch(44)

B8:

42LdFalse

43StLoc[5](loc0: bool)

B9:

44MoveLoc[5](loc0: bool)

45BrFalse(47)

B10:

46Branch(55)

B11:

47MoveLoc[1](Arg1: &mut Pairs)

48Pop

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

50Pop

51MoveLoc[0](Arg0: &GlobalConfig)

52Pop

53LdConst[5](u64: 105)

54Abort

B12:

55CopyLoc[0](Arg0: &GlobalConfig)

56Call config::get_allow_create_pair(&GlobalConfig): bool

57Not

58BrFalse(64)

B13:

59CopyLoc[0](Arg0: &GlobalConfig)

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

61FreezeRef

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

63Call config::check_pool_manager_role(&GlobalConfig, address)

B14:

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

65StLoc[12](loc7: TypeName)

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

67StLoc[13](loc8: TypeName)

68CopyLoc[12](loc7: TypeName)

69CopyLoc[13](loc8: TypeName)

70Neq

71BrFalse(73)

B15:

72Branch(81)

B16:

73MoveLoc[1](Arg1: &mut Pairs)

74Pop

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

76Pop

77MoveLoc[0](Arg0: &GlobalConfig)

78Pop

79LdConst[2](u64: 102)

80Abort

B17:

81CopyLoc[0](Arg0: &GlobalConfig)

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

83Call config::is_in_whitelist(&GlobalConfig, TypeName): bool

84BrFalse(88)

B18:

85LdTrue

86StLoc[6](loc1: bool)

87Branch(92)

B19:

88CopyLoc[0](Arg0: &GlobalConfig)

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

90Call config::is_in_whitelist(&GlobalConfig, TypeName): bool

91StLoc[6](loc1: bool)

B20:

92MoveLoc[6](loc1: bool)

93BrFalse(95)

B21:

94Branch(103)

B22:

95MoveLoc[1](Arg1: &mut Pairs)

96Pop

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

98Pop

99MoveLoc[0](Arg0: &GlobalConfig)

100Pop

101LdConst[3](u64: 103)

102Abort

B23:

103CopyLoc[3](Arg3: u16)

104Call new_pair_key<Ty0, Ty1>(u16): ID

105StLoc[19](loc14: ID)

106CopyLoc[1](Arg1: &mut Pairs)

107ImmBorrowField[0](Pairs.list: Table<ID, PairSimpleInfo>)

108CopyLoc[19](loc14: ID)

109Call table::contains<ID, PairSimpleInfo>(&Table<ID, PairSimpleInfo>, ID): bool

110BrFalse(119)

B24:

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

112Pop

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

114Pop

115MoveLoc[0](Arg0: &GlobalConfig)

116Pop

117LdConst[4](u64: 104)

118Abort

B25:

119CopyLoc[2](Arg2: u32)

120CopyLoc[3](Arg3: u16)

121CopyLoc[0](Arg0: &GlobalConfig)

122CopyLoc[3](Arg3: u16)

123Call config::base_factor(&GlobalConfig, u16): u32

124CopyLoc[0](Arg0: &GlobalConfig)

125CopyLoc[3](Arg3: u16)

126Call config::filter_period(&GlobalConfig, u16): u16

127CopyLoc[0](Arg0: &GlobalConfig)

128CopyLoc[3](Arg3: u16)

129Call config::decay_period(&GlobalConfig, u16): u16

130CopyLoc[0](Arg0: &GlobalConfig)

131CopyLoc[3](Arg3: u16)

132Call config::reduction_factor(&GlobalConfig, u16): u16

133CopyLoc[0](Arg0: &GlobalConfig)

134CopyLoc[3](Arg3: u16)

135Call config::variable_fee_control(&GlobalConfig, u16): u32

136CopyLoc[0](Arg0: &GlobalConfig)

137CopyLoc[3](Arg3: u16)

138Call config::protocol_share(&GlobalConfig, u16): u16

139MoveLoc[0](Arg0: &GlobalConfig)

140CopyLoc[3](Arg3: u16)

141Call config::max_volatility_accumulator(&GlobalConfig, u16): u32

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

143Call lb_pair::new<Ty0, Ty1>(u32, u16, u32, u16, u16, u16, u32, u16, u32, &mut TxContext): LBPair<Ty0, Ty1>

144StLoc[14](loc9: LBPair<Ty0, Ty1>)

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

146ImmBorrowField[1](Pairs.index: u64)

147ReadRef

148LdU64(1)

149Add

150CopyLoc[1](Arg1: &mut Pairs)

151MutBorrowField[1](Pairs.index: u64)

152WriteRef

153ImmBorrowLoc[14](loc9: LBPair<Ty0, Ty1>)

154Call object::id<LBPair<Ty0, Ty1>>(&LBPair<Ty0, Ty1>): ID

155StLoc[17](loc12: ID)

156CopyLoc[17](loc12: ID)

157CopyLoc[19](loc14: ID)

158CopyLoc[3](Arg3: u16)

159CopyLoc[12](loc7: TypeName)

160CopyLoc[13](loc8: TypeName)

161Pack[0](PairSimpleInfo)

162StLoc[18](loc13: PairSimpleInfo)

163MoveLoc[1](Arg1: &mut Pairs)

164MutBorrowField[0](Pairs.list: Table<ID, PairSimpleInfo>)

165MoveLoc[19](loc14: ID)

166MoveLoc[18](loc13: PairSimpleInfo)

167Call table::add<ID, PairSimpleInfo>(&mut Table<ID, PairSimpleInfo>, ID, PairSimpleInfo)

168MoveLoc[17](loc12: ID)

169StLoc[7](loc2: ID)

170MoveLoc[12](loc7: TypeName)

171Call type_name::into_string(TypeName): String

172Call string::from_ascii(String): String

173StLoc[8](loc3: String)

174MoveLoc[13](loc8: TypeName)

175Call type_name::into_string(TypeName): String

176Call string::from_ascii(String): String

177StLoc[9](loc4: String)

178MoveLoc[3](Arg3: u16)

179StLoc[10](loc5: u16)

180MoveLoc[2](Arg2: u32)

181StLoc[11](loc6: u32)

182MoveLoc[7](loc2: ID)

183MoveLoc[10](loc5: u16)

184MoveLoc[8](loc3: String)

185MoveLoc[9](loc4: String)

186MoveLoc[11](loc6: u32)

187Pack[3](CreatePairEvent)

188Call event::emit<CreatePairEvent>(CreatePairEvent)

189MoveLoc[14](loc9: LBPair<Ty0, Ty1>)

190Call transfer::public_share_object<LBPair<Ty0, Ty1>>(LBPair<Ty0, Ty1>)

191Ret

}

public index(Arg0: &Pairs): u64 {

B0:

0MoveLoc[0](Arg0: &Pairs)

1ImmBorrowField[1](Pairs.index: u64)

2ReadRef

3Ret

}

public coin_types(Arg0: &PairSimpleInfo): TypeName * TypeName {

B0:

0CopyLoc[0](Arg0: &PairSimpleInfo)

1ImmBorrowField[2](PairSimpleInfo.coin_type_a: TypeName)

2ReadRef

3MoveLoc[0](Arg0: &PairSimpleInfo)

4ImmBorrowField[3](PairSimpleInfo.coin_type_b: TypeName)

5ReadRef

6Ret

}

public new_pair_key<Ty0, Ty1>(Arg0: u16): ID {

L1: loc0: bool

L2: loc1: u8

L3: loc2: u8

L4: loc3: vector<u8>

L5: loc4: vector<u8>

L6: loc5: u64

L7: loc6: bool

L8: loc7: String

L9: loc8: String

B0:

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

1Call type_name::into_string(TypeName): String

2StLoc[8](loc7: String)

3ImmBorrowLoc[8](loc7: String)

4Call ascii::as_bytes(&String): &vector<u8>

5ReadRef

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

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

8Call type_name::into_string(TypeName): String

9StLoc[9](loc8: String)

10ImmBorrowLoc[9](loc8: String)

11Call ascii::as_bytes(&String): &vector<u8>

12ReadRef

13StLoc[5](loc4: vector<u8>)

14LdU64(0)

15StLoc[6](loc5: u64)

16LdFalse

17StLoc[7](loc6: bool)

B1:

18CopyLoc[6](loc5: u64)

19ImmBorrowLoc[5](loc4: vector<u8>)

20VecLen(41)

21Lt

22BrFalse(67)

B2:

23Branch(24)

B3:

24ImmBorrowLoc[5](loc4: vector<u8>)

25CopyLoc[6](loc5: u64)

26VecImmBorrow(41)

27ReadRef

28StLoc[3](loc2: u8)

29CopyLoc[7](loc6: bool)

30Not

31BrFalse(38)

B4:

32CopyLoc[6](loc5: u64)

33ImmBorrowLoc[4](loc3: vector<u8>)

34VecLen(41)

35Lt

36StLoc[1](loc0: bool)

37Branch(40)

B5:

38LdFalse

39StLoc[1](loc0: bool)

B6:

40MoveLoc[1](loc0: bool)

41BrFalse(59)

B7:

42ImmBorrowLoc[4](loc3: vector<u8>)

43CopyLoc[6](loc5: u64)

44VecImmBorrow(41)

45ReadRef

46StLoc[2](loc1: u8)

47CopyLoc[2](loc1: u8)

48CopyLoc[3](loc2: u8)

49Lt

50BrFalse(53)

B8:

51LdU64(6)

52Abort

B9:

53MoveLoc[2](loc1: u8)

54CopyLoc[3](loc2: u8)

55Gt

56BrFalse(59)

B10:

57LdTrue

58StLoc[7](loc6: bool)

B11:

59MutBorrowLoc[4](loc3: vector<u8>)

60MoveLoc[3](loc2: u8)

61VecPushBack(41)

62MoveLoc[6](loc5: u64)

63LdU64(1)

64Add

65StLoc[6](loc5: u64)

66Branch(18)

B12:

67MoveLoc[7](loc6: bool)

68Not

69BrFalse(86)

B13:

70ImmBorrowLoc[4](loc3: vector<u8>)

71VecLen(41)

72ImmBorrowLoc[5](loc4: vector<u8>)

73VecLen(41)

74Lt

75BrFalse(78)

B14:

76LdU64(6)

77Abort

B15:

78ImmBorrowLoc[4](loc3: vector<u8>)

79VecLen(41)

80ImmBorrowLoc[5](loc4: vector<u8>)

81VecLen(41)

82Eq

83BrFalse(86)

B16:

84LdU64(3)

85Abort

B17:

86MutBorrowLoc[4](loc3: vector<u8>)

87ImmBorrowLoc[0](Arg0: u16)

88Call bcs::to_bytes<u16>(&u16): vector<u8>

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

90ImmBorrowLoc[4](loc3: vector<u8>)

91Call hash::blake2b256(&vector<u8>): vector<u8>

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

93Ret

}

public pair_id(Arg0: &PairSimpleInfo): ID {

B0:

0MoveLoc[0](Arg0: &PairSimpleInfo)

1ImmBorrowField[4](PairSimpleInfo.pair_id: ID)

2ReadRef

3Ret

}

public pair_key(Arg0: &PairSimpleInfo): ID {

B0:

0MoveLoc[0](Arg0: &PairSimpleInfo)

1ImmBorrowField[5](PairSimpleInfo.pair_key: ID)

2ReadRef

3Ret

}

public pool_simple_info(Arg0: &Pairs, Arg1: ID): &PairSimpleInfo {

B0:

0MoveLoc[0](Arg0: &Pairs)

1ImmBorrowField[0](Pairs.list: Table<ID, PairSimpleInfo>)

2MoveLoc[1](Arg1: ID)

3Call table::borrow<ID, PairSimpleInfo>(&Table<ID, PairSimpleInfo>, ID): &PairSimpleInfo

4Ret

}

public bin_step(Arg0: &PairSimpleInfo): u32 {

B0:

0MoveLoc[0](Arg0: &PairSimpleInfo)

1ImmBorrowField[6](PairSimpleInfo.bin_step: u16)

2ReadRef

3CastU32

4Ret

}

Constants [

0 => u64: 100

1 => u64: 101

2 => u64: 102

3 => u64: 103

4 => u64: 104

5 => u64: 105

]

}