utils

Module0xd5ea…ecde

Move path: 0x859e…b7cb::utils
Functions: 1818 public, 0 entry
Structs: 2
Friend modules: None

utils

Bytecode571 lines

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

// Move bytecode v6

module 859eb18bd5b5e8cc32deb6dfb1c39941008ab3c6e27f0b8ce2364be7102bb7cb.utils {

use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::package;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::table_vec;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;

struct Marker<phantom Ty0> has copy, drop, store {

dummy_field: bool

}

struct IsShared has copy, drop, store {

dummy_field: bool

}

public marker<Ty0>(): Marker<Ty0> {

B0:

0LdFalse

1PackGeneric[0](Marker<Ty0>)

2Ret

}

public is_shared(): IsShared {

B0:

0LdFalse

1Pack[1](IsShared)

2Ret

}

public get_package_module_type<Ty0>(): String * String * String {

B0:

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

1Call type_name::into_string(TypeName): String

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

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

4Call get_package_module_type_raw(String): String * String * String

5Ret

}

public get_package_module_type_raw(Arg0: String): String * String * String {

L1: loc0: String

L2: loc1: u64

L3: loc2: String

L4: loc3: String

L5: loc4: u64

L6: loc5: String

L7: loc6: String

B0:

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

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

2StLoc[1](loc0: String)

3ImmBorrowLoc[0](Arg0: String)

4ImmBorrowLoc[1](loc0: String)

5Call string::index_of(&String, &String): u64

6StLoc[5](loc4: u64)

7ImmBorrowLoc[0](Arg0: String)

8LdU64(0)

9ImmBorrowLoc[0](Arg0: String)

10ImmBorrowLoc[1](loc0: String)

11Call string::index_of(&String, &String): u64

12Call string::sub_string(&String, u64, u64): String

13StLoc[4](loc3: String)

14ImmBorrowLoc[0](Arg0: String)

15MoveLoc[5](loc4: u64)

16LdU64(2)

17Add

18ImmBorrowLoc[0](Arg0: String)

19Call string::length(&String): u64

20Call string::sub_string(&String, u64, u64): String

21StLoc[6](loc5: String)

22ImmBorrowLoc[6](loc5: String)

23ImmBorrowLoc[1](loc0: String)

24Call string::index_of(&String, &String): u64

25StLoc[2](loc1: u64)

26ImmBorrowLoc[6](loc5: String)

27LdU64(0)

28CopyLoc[2](loc1: u64)

29Call string::sub_string(&String, u64, u64): String

30StLoc[3](loc2: String)

31ImmBorrowLoc[6](loc5: String)

32MoveLoc[2](loc1: u64)

33LdU64(2)

34Add

35ImmBorrowLoc[6](loc5: String)

36Call string::length(&String): u64

37Call string::sub_string(&String, u64, u64): String

38StLoc[7](loc6: String)

39MoveLoc[4](loc3: String)

40MoveLoc[3](loc2: String)

41MoveLoc[7](loc6: String)

42Ret

}

public assert_same_module<Ty0, Ty1>() {

L0: loc0: String

L1: loc1: String

L2: loc2: String

L3: loc3: String

B0:

0Call get_package_module_type<Ty0>(): String * String * String

1Pop

2StLoc[0](loc0: String)

3StLoc[2](loc2: String)

4Call get_package_module_type<Ty1>(): String * String * String

5Pop

6StLoc[1](loc1: String)

7StLoc[3](loc3: String)

8MoveLoc[2](loc2: String)

9MoveLoc[3](loc3: String)

10Eq

11BrFalse(13)

B1:

12Branch(15)

B2:

13LdConst[2](u64: 3)

14Abort

B3:

15MoveLoc[0](loc0: String)

16MoveLoc[1](loc1: String)

17Eq

18BrFalse(20)

B4:

19Branch(22)

B5:

20LdConst[3](u64: 4)

21Abort

B6:

22Ret

}

public assert_same_module_as_witness<Ty0, Ty1>() {

L0: loc0: String

L1: loc1: String

L2: loc2: String

L3: loc3: String

L4: loc4: String

B0:

0Call get_package_module_type<Ty0>(): String * String * String

1Pop

2StLoc[0](loc0: String)

3StLoc[2](loc2: String)

4Call get_package_module_type<Ty1>(): String * String * String

5StLoc[4](loc4: String)

6StLoc[1](loc1: String)

7StLoc[3](loc3: String)

8MoveLoc[2](loc2: String)

9MoveLoc[3](loc3: String)

10Eq

11BrFalse(13)

B1:

12Branch(15)

B2:

13LdConst[2](u64: 3)

14Abort

B3:

15MoveLoc[0](loc0: String)

16MoveLoc[1](loc1: String)

17Eq

18BrFalse(20)

B4:

19Branch(22)

B5:

20LdConst[3](u64: 4)

21Abort

B6:

22MoveLoc[4](loc4: String)

23LdConst[6](vector<u8>: "Wit..)

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

25Eq

26BrFalse(28)

B7:

27Branch(30)

B8:

28LdConst[4](u64: 5)

29Abort

B9:

30Ret

}

public assert_publisher<Ty0>(Arg0: &Publisher) {

B0:

0MoveLoc[0](Arg0: &Publisher)

1Call package::from_package<Ty0>(&Publisher): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[1](u64: 2)

5Abort

B3:

6Ret

}

public originbyte_docs_url(): String {

B0:

0LdConst[7](vector<u8>: "htt..)

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

2Ret

}

public table_from_vec_map<Ty0: copy + drop + store, Ty1: store>(Arg0: VecMap<Ty0, Ty1>, Arg1: &mut TxContext): Table<Ty0, Ty1> {

L2: loc0: Ty1

L3: loc1: Ty0

L4: loc2: vector<Ty0>

L5: loc3: u64

L6: loc4: Table<Ty0, Ty1>

L7: loc5: vector<Ty1>

B0:

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

1Call table::new<Ty0, Ty1>(&mut TxContext): Table<Ty0, Ty1>

2StLoc[6](loc4: Table<Ty0, Ty1>)

3MoveLoc[0](Arg0: VecMap<Ty0, Ty1>)

4Call vec_map::into_keys_values<Ty0, Ty1>(VecMap<Ty0, Ty1>): vector<Ty0> * vector<Ty1>

5StLoc[7](loc5: vector<Ty1>)

6StLoc[4](loc2: vector<Ty0>)

7ImmBorrowLoc[7](loc5: vector<Ty1>)

8VecLen(30)

9StLoc[5](loc3: u64)

B1:

10CopyLoc[5](loc3: u64)

11LdU64(0)

12Gt

13BrFalse(30)

B2:

14Branch(15)

B3:

15MutBorrowLoc[7](loc5: vector<Ty1>)

16VecPopBack(30)

17StLoc[2](loc0: Ty1)

18MutBorrowLoc[4](loc2: vector<Ty0>)

19VecPopBack(21)

20StLoc[3](loc1: Ty0)

21MutBorrowLoc[6](loc4: Table<Ty0, Ty1>)

22MoveLoc[3](loc1: Ty0)

23MoveLoc[2](loc0: Ty1)

24Call table::add<Ty0, Ty1>(&mut Table<Ty0, Ty1>, Ty0, Ty1)

25MoveLoc[5](loc3: u64)

26LdU64(1)

27Sub

28StLoc[5](loc3: u64)

29Branch(10)

B4:

30MoveLoc[7](loc5: vector<Ty1>)

31VecUnpack(30, 0)

32MoveLoc[4](loc2: vector<Ty0>)

33VecUnpack(21, 0)

34MoveLoc[6](loc4: Table<Ty0, Ty1>)

35Ret

}

public table_vec_from_vec<Ty0: store>(Arg0: vector<Ty0>, Arg1: &mut TxContext): TableVec<Ty0> {

L2: loc0: Ty0

L3: loc1: u64

L4: loc2: TableVec<Ty0>

B0:

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

1Call table_vec::empty<Ty0>(&mut TxContext): TableVec<Ty0>

2StLoc[4](loc2: TableVec<Ty0>)

3ImmBorrowLoc[0](Arg0: vector<Ty0>)

4VecLen(21)

5StLoc[3](loc1: u64)

B1:

6CopyLoc[3](loc1: u64)

7LdU64(0)

8Gt

9BrFalse(22)

B2:

10Branch(11)

B3:

11MutBorrowLoc[0](Arg0: vector<Ty0>)

12VecPopBack(21)

13StLoc[2](loc0: Ty0)

14MutBorrowLoc[4](loc2: TableVec<Ty0>)

15MoveLoc[2](loc0: Ty0)

16Call table_vec::push_back<Ty0>(&mut TableVec<Ty0>, Ty0)

17MoveLoc[3](loc1: u64)

18LdU64(1)

19Sub

20StLoc[3](loc1: u64)

21Branch(6)

B4:

22MoveLoc[0](Arg0: vector<Ty0>)

23VecUnpack(21, 0)

24MoveLoc[4](loc2: TableVec<Ty0>)

25Ret

}

public vec_set_from_vec<Ty0: copy + drop + store>(Arg0: &vector<Ty0>): VecSet<Ty0> {

L1: loc0: &Ty0

L2: loc1: u64

L3: loc2: VecSet<Ty0>

B0:

0Call vec_set::empty<Ty0>(): VecSet<Ty0>

1StLoc[3](loc2: VecSet<Ty0>)

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

3VecLen(21)

4StLoc[2](loc1: u64)

B1:

5CopyLoc[2](loc1: u64)

6LdU64(0)

7Gt

8BrFalse(25)

B2:

9Branch(10)

B3:

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

11CopyLoc[2](loc1: u64)

12LdU64(1)

13Sub

14VecImmBorrow(21)

15StLoc[1](loc0: &Ty0)

16MutBorrowLoc[3](loc2: VecSet<Ty0>)

17MoveLoc[1](loc0: &Ty0)

18ReadRef

19Call vec_set::insert<Ty0>(&mut VecSet<Ty0>, Ty0)

20MoveLoc[2](loc1: u64)

21LdU64(1)

22Sub

23StLoc[2](loc1: u64)

24Branch(5)

B4:

25MoveLoc[0](Arg0: &vector<Ty0>)

26Pop

27MoveLoc[3](loc2: VecSet<Ty0>)

28Ret

}

public vec_map_entries<Ty0: copy + drop, Ty1: copy>(Arg0: &VecMap<Ty0, Ty1>): vector<Ty1> {

L1: loc0: u64

L2: loc1: &Ty0

L3: loc2: vector<Ty0>

L4: loc3: u64

L5: loc4: &Ty1

L6: loc5: vector<Ty1>

B0:

0CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)

1Call vec_map::keys<Ty0, Ty1>(&VecMap<Ty0, Ty1>): vector<Ty0>

2StLoc[3](loc2: vector<Ty0>)

3LdU64(0)

4StLoc[1](loc0: u64)

5ImmBorrowLoc[3](loc2: vector<Ty0>)

6VecLen(21)

7StLoc[4](loc3: u64)

8VecPack(30, 0)

9StLoc[6](loc5: vector<Ty1>)

B1:

10CopyLoc[1](loc0: u64)

11CopyLoc[4](loc3: u64)

12Lt

13BrFalse(32)

B2:

14Branch(15)

B3:

15ImmBorrowLoc[3](loc2: vector<Ty0>)

16CopyLoc[1](loc0: u64)

17VecImmBorrow(21)

18StLoc[2](loc1: &Ty0)

19CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)

20MoveLoc[2](loc1: &Ty0)

21Call vec_map::get<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): &Ty1

22StLoc[5](loc4: &Ty1)

23MutBorrowLoc[6](loc5: vector<Ty1>)

24MoveLoc[5](loc4: &Ty1)

25ReadRef

26VecPushBack(30)

27MoveLoc[1](loc0: u64)

28LdU64(1)

29Add

30StLoc[1](loc0: u64)

31Branch(10)

B4:

32MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)

33Pop

34MoveLoc[6](loc5: vector<Ty1>)

35Ret

}

public sum_vector(Arg0: vector<u64>): u64 {

L1: loc0: u64

L2: loc1: u64

L3: loc2: u64

B0:

0ImmBorrowLoc[0](Arg0: vector<u64>)

1VecLen(15)

2StLoc[1](loc0: u64)

3LdU64(0)

4StLoc[2](loc1: u64)

B1:

5CopyLoc[1](loc0: u64)

6LdU64(0)

7Gt

8BrFalse(22)

B2:

9Branch(10)

B3:

10MutBorrowLoc[0](Arg0: vector<u64>)

11VecPopBack(15)

12StLoc[3](loc2: u64)

13MoveLoc[2](loc1: u64)

14MoveLoc[3](loc2: u64)

15Add

16StLoc[2](loc1: u64)

17MoveLoc[1](loc0: u64)

18LdU64(1)

19Sub

20StLoc[1](loc0: u64)

21Branch(5)

B4:

22MoveLoc[2](loc1: u64)

23Ret

}

public insert_vec_in_vec_set<Ty0: copy + drop + store>(Arg0: &mut VecSet<Ty0>, Arg1: vector<Ty0>) {

L2: loc0: Ty0

L3: loc1: u64

B0:

0ImmBorrowLoc[1](Arg1: vector<Ty0>)

1VecLen(21)

2StLoc[3](loc1: u64)

B1:

3CopyLoc[3](loc1: u64)

4LdU64(0)

5Gt

6BrFalse(19)

B2:

7Branch(8)

B3:

8MutBorrowLoc[1](Arg1: vector<Ty0>)

9VecPopBack(21)

10StLoc[2](loc0: Ty0)

11CopyLoc[0](Arg0: &mut VecSet<Ty0>)

12MoveLoc[2](loc0: Ty0)

13Call vec_set::insert<Ty0>(&mut VecSet<Ty0>, Ty0)

14MoveLoc[3](loc1: u64)

15LdU64(1)

16Sub

17StLoc[3](loc1: u64)

18Branch(3)

B4:

19MoveLoc[0](Arg0: &mut VecSet<Ty0>)

20Pop

21MoveLoc[1](Arg1: vector<Ty0>)

22VecUnpack(21, 0)

23Ret

}

public insert_vec_in_table<Ty0: store>(Arg0: &mut TableVec<Ty0>, Arg1: vector<Ty0>) {

L2: loc0: Ty0

L3: loc1: u64

B0:

0ImmBorrowLoc[1](Arg1: vector<Ty0>)

1VecLen(21)

2StLoc[3](loc1: u64)

B1:

3CopyLoc[3](loc1: u64)

4LdU64(0)

5Gt

6BrFalse(19)

B2:

7Branch(8)

B3:

8MutBorrowLoc[1](Arg1: vector<Ty0>)

9VecPopBack(21)

10StLoc[2](loc0: Ty0)

11CopyLoc[0](Arg0: &mut TableVec<Ty0>)

12MoveLoc[2](loc0: Ty0)

13Call table_vec::push_back<Ty0>(&mut TableVec<Ty0>, Ty0)

14MoveLoc[3](loc1: u64)

15LdU64(1)

16Sub

17StLoc[3](loc1: u64)

18Branch(3)

B4:

19MoveLoc[0](Arg0: &mut TableVec<Ty0>)

20Pop

21MoveLoc[1](Arg1: vector<Ty0>)

22VecUnpack(21, 0)

23Ret

}

public bps(): u16 {

B0:

0LdU16(10000)

1Ret

}

public assert_package_publisher<Ty0>(Arg0: &Publisher) {

B0:

0MoveLoc[0](Arg0: &Publisher)

1Call package::from_package<Ty0>(&Publisher): bool

2BrFalse(4)

B1:

3Branch(6)

B2:

4LdConst[1](u64: 2)

5Abort

B3:

6Ret

}

public from_vec_to_map<Ty0: copy + drop, Ty1: drop>(Arg0: vector<Ty0>, Arg1: vector<Ty1>): VecMap<Ty0, Ty1> {

L2: loc0: u64

L3: loc1: Ty0

L4: loc2: VecMap<Ty0, Ty1>

L5: loc3: u64

L6: loc4: Ty1

B0:

0ImmBorrowLoc[0](Arg0: vector<Ty0>)

1VecLen(21)

2ImmBorrowLoc[1](Arg1: vector<Ty1>)

3VecLen(30)

4Eq

5BrFalse(7)

B1:

6Branch(9)

B2:

7LdConst[0](u64: 1)

8Abort

B3:

9LdU64(0)

10StLoc[2](loc0: u64)

11ImmBorrowLoc[0](Arg0: vector<Ty0>)

12VecLen(21)

13StLoc[5](loc3: u64)

14Call vec_map::empty<Ty0, Ty1>(): VecMap<Ty0, Ty1>

15StLoc[4](loc2: VecMap<Ty0, Ty1>)

B4:

16CopyLoc[2](loc0: u64)

17CopyLoc[5](loc3: u64)

18Lt

19BrFalse(36)

B5:

20Branch(21)

B6:

21MutBorrowLoc[0](Arg0: vector<Ty0>)

22VecPopBack(21)

23StLoc[3](loc1: Ty0)

24MutBorrowLoc[1](Arg1: vector<Ty1>)

25VecPopBack(30)

26StLoc[6](loc4: Ty1)

27MutBorrowLoc[4](loc2: VecMap<Ty0, Ty1>)

28MoveLoc[3](loc1: Ty0)

29MoveLoc[6](loc4: Ty1)

30Call vec_map::insert<Ty0, Ty1>(&mut VecMap<Ty0, Ty1>, Ty0, Ty1)

31MoveLoc[2](loc0: u64)

32LdU64(1)

33Add

34StLoc[2](loc0: u64)

35Branch(16)

B7:

36MoveLoc[4](loc2: VecMap<Ty0, Ty1>)

37Ret

}

Constants [

0 => u64: 1

1 => u64: 2

2 => u64: 3

3 => u64: 4

4 => u64: 5

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

6 => vector<u8>: "Witness" // interpreted as UTF8 string

7 => vector<u8>: "https://docs.originbyte.io" // interpreted as UTF8 string

]

}