Switchboard package::service_queue bytecode | tide

Switchboard package::service_queue bytecode | tide

Bytecode970 lines

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

// Move bytecode v6

module fd2e0f4383df3ec9106326dcd9a20510cdce72146754296deed15403fcd3df8b.service_queue {

use 0000000000000000000000000000000000000000000000000000000000000001::vector;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::table;

use 0000000000000000000000000000000000000000000000000000000000000002::table_vec;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use fd2e0f4383df3ec9106326dcd9a20510cdce72146754296deed15403fcd3df8b::permission;

use fd2e0f4383df3ec9106326dcd9a20510cdce72146754296deed15403fcd3df8b::switchboard;

use 08d79f4d920b03d88faca1e421af023a87fbb1e4a6fd200248e6e9998d09e470::errors;

use 08d79f4d920b03d88faca1e421af023a87fbb1e4a6fd200248e6e9998d09e470::utils;

struct ServiceQueue<phantom Ty0> has key {

id: UID,

authority: address,

node_timeout: u64,

max_size: u64,

mr_enclaves: vector<vector<u8>>,

max_quote_verification_age: u64,

allow_authority_override_after: u64,

require_authority_heartbeat_permission: bool,

require_usage_permissions: bool,

verifier_queue_addr: address,

enable_content_hash: bool,

reward: u64,

curr_idx: u64,

gc_idx: u64,

node_idx: u64,

last_hb: u64,

data: TableVec<address>,

heartbeats: Table<address, u64>,

permissions: Table<address, Permission>,

escrows: Table<address, Balance<Ty0>>,

version: u64

}

public(friend) set_configs<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: address, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: u64, Arg7: bool, Arg8: bool, Arg9: address) {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

11MoveLoc[1](Arg1: address)

12CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

13MutBorrowFieldGeneric[1](ServiceQueue.authority: address)

14WriteRef

15MoveLoc[2](Arg2: u64)

16CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

17MutBorrowFieldGeneric[2](ServiceQueue.reward: u64)

18WriteRef

19MoveLoc[3](Arg3: u64)

20CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

21MutBorrowFieldGeneric[3](ServiceQueue.node_timeout: u64)

22WriteRef

23MoveLoc[4](Arg4: u64)

24CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

25MutBorrowFieldGeneric[4](ServiceQueue.max_size: u64)

26WriteRef

27MoveLoc[5](Arg5: u64)

28CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

29MutBorrowFieldGeneric[5](ServiceQueue.max_quote_verification_age: u64)

30WriteRef

31MoveLoc[6](Arg6: u64)

32CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

33MutBorrowFieldGeneric[6](ServiceQueue.allow_authority_override_after: u64)

34WriteRef

35MoveLoc[7](Arg7: bool)

36CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

37MutBorrowFieldGeneric[7](ServiceQueue.require_authority_heartbeat_permission: bool)

38WriteRef

39MoveLoc[8](Arg8: bool)

40CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

41MutBorrowFieldGeneric[8](ServiceQueue.require_usage_permissions: bool)

42WriteRef

43MoveLoc[9](Arg9: address)

44MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

45MutBorrowFieldGeneric[9](ServiceQueue.verifier_queue_addr: address)

46WriteRef

47Ret

}

public has_mr_enclave<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: vector<u8>): bool {

L2: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

11LdU64(0)

12StLoc[2](loc0: u64)

B4:

13CopyLoc[2](loc0: u64)

14CopyLoc[0](Arg0: &ServiceQueue<Ty0>)

15ImmBorrowFieldGeneric[10](ServiceQueue.mr_enclaves: vector<vector<u8>>)

16VecLen(28)

17Lt

18BrFalse(36)

B5:

19Branch(20)

B6:

20CopyLoc[0](Arg0: &ServiceQueue<Ty0>)

21ImmBorrowFieldGeneric[10](ServiceQueue.mr_enclaves: vector<vector<u8>>)

22CopyLoc[2](loc0: u64)

23VecImmBorrow(28)

24ImmBorrowLoc[1](Arg1: vector<u8>)

25Eq

26BrFalse(31)

B7:

27MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

28Pop

29LdTrue

30Ret

B8:

31MoveLoc[2](loc0: u64)

32LdU64(1)

33Add

34StLoc[2](loc0: u64)

35Branch(13)

B9:

36MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

37Pop

38LdFalse

39Ret

}

public(friend) add_mr_enclave<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: vector<u8>) {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

11MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

12MutBorrowFieldGeneric[10](ServiceQueue.mr_enclaves: vector<vector<u8>>)

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

14VecPushBack(28)

15Ret

}

public(friend) remove_mr_enclave<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: vector<u8>): bool {

L2: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

11LdU64(0)

12StLoc[2](loc0: u64)

B4:

13CopyLoc[2](loc0: u64)

14CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

15ImmBorrowFieldGeneric[10](ServiceQueue.mr_enclaves: vector<vector<u8>>)

16VecLen(28)

17Lt

18BrFalse(39)

B5:

19Branch(20)

B6:

20CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

21ImmBorrowFieldGeneric[10](ServiceQueue.mr_enclaves: vector<vector<u8>>)

22CopyLoc[2](loc0: u64)

23VecImmBorrow(28)

24ImmBorrowLoc[1](Arg1: vector<u8>)

25Eq

26BrFalse(34)

B7:

27MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

28MutBorrowFieldGeneric[10](ServiceQueue.mr_enclaves: vector<vector<u8>>)

29MoveLoc[2](loc0: u64)

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

31Pop

32LdTrue

33Ret

B8:

34MoveLoc[2](loc0: u64)

35LdU64(1)

36Add

37StLoc[2](loc0: u64)

38Branch(13)

B9:

39MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

40Pop

41LdFalse

42Ret

}

public last_heartbeat<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[11](ServiceQueue.last_hb: u64)

2ReadRef

3Ret

}

public max_quote_verification_age<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[5](ServiceQueue.max_quote_verification_age: u64)

2ReadRef

3Ret

}

public allow_authority_override_after<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[6](ServiceQueue.allow_authority_override_after: u64)

2ReadRef

3Ret

}

public require_authority_heartbeat_permission<Ty0>(Arg0: &ServiceQueue<Ty0>): bool {

B0:

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

1ImmBorrowFieldGeneric[7](ServiceQueue.require_authority_heartbeat_permission: bool)

2ReadRef

3Ret

}

public require_usage_permissions<Ty0>(Arg0: &ServiceQueue<Ty0>): bool {

B0:

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

1ImmBorrowFieldGeneric[8](ServiceQueue.require_usage_permissions: bool)

2ReadRef

3Ret

}

public has_authority<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: &TxContext): bool {

B0:

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

1ImmBorrowFieldGeneric[1](ServiceQueue.authority: address)

2ReadRef

3MoveLoc[1](Arg1: &TxContext)

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

5Eq

6Ret

}

public reward<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[2](ServiceQueue.reward: u64)

2ReadRef

3Ret

}

public node_idx<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[12](ServiceQueue.node_idx: u64)

2ReadRef

3Ret

}

public authority<Ty0>(Arg0: &ServiceQueue<Ty0>): address {

B0:

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

1ImmBorrowFieldGeneric[1](ServiceQueue.authority: address)

2ReadRef

3Ret

}

public data_len<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

2Call table_vec::length<address>(&TableVec<address>): u64

3Ret

}

public verifier_queue_addr<Ty0>(Arg0: &ServiceQueue<Ty0>): address {

B0:

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

1ImmBorrowFieldGeneric[9](ServiceQueue.verifier_queue_addr: address)

2ReadRef

3Ret

}

public service_queue_address<Ty0>(Arg0: &ServiceQueue<Ty0>): address {

B0:

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

1ImmBorrowFieldGeneric[14](ServiceQueue.id: UID)

2Call object::uid_to_address(&UID): address

3Ret

}

public has<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: address): bool {

L2: loc0: u64

B0:

0LdU64(0)

1StLoc[2](loc0: u64)

B1:

2CopyLoc[2](loc0: u64)

3CopyLoc[0](Arg0: &ServiceQueue<Ty0>)

4ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

5Call table_vec::length<address>(&TableVec<address>): u64

6Lt

7BrFalse(25)

B2:

8Branch(9)

B3:

9CopyLoc[0](Arg0: &ServiceQueue<Ty0>)

10ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

11CopyLoc[2](loc0: u64)

12Call table_vec::borrow<address>(&TableVec<address>, u64): &address

13ImmBorrowLoc[1](Arg1: address)

14Eq

15BrFalse(20)

B4:

16MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

17Pop

18LdTrue

19Ret

B5:

20MoveLoc[2](loc0: u64)

21LdU64(1)

22Add

23StLoc[2](loc0: u64)

24Branch(2)

B6:

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

26Pop

27LdFalse

28Ret

}

public max_size<Ty0>(Arg0: &ServiceQueue<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[4](ServiceQueue.max_size: u64)

2ReadRef

3Ret

}

public enable_content_hash<Ty0>(Arg0: &ServiceQueue<Ty0>): bool {

B0:

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

1ImmBorrowFieldGeneric[15](ServiceQueue.enable_content_hash: bool)

2ReadRef

3Ret

}

public(friend) service_queue_create<Ty0>(Arg0: address, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: bool, Arg8: address, Arg9: bool, Arg10: &mut TxContext): ServiceQueue<Ty0> {

L11: loc0: UID

L12: loc1: u64

L13: loc2: address

L14: loc3: bool

L15: loc4: TableVec<address>

L16: loc5: Table<address, u64>

L17: loc6: Table<address, Permission>

L18: loc7: address

L19: loc8: Table<address, Balance<Ty0>>

L20: loc9: u64

L21: loc10: address

L22: loc11: u64

L23: loc12: u64

L24: loc13: vector<vector<u8>>

L25: loc14: u64

L26: loc15: u64

L27: loc16: bool

L28: loc17: bool

L29: loc18: ServiceQueue<Ty0>

B0:

0CopyLoc[10](Arg10: &mut TxContext)

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

2StLoc[11](loc0: UID)

3MoveLoc[0](Arg0: address)

4StLoc[18](loc7: address)

5MoveLoc[2](Arg2: u64)

6StLoc[22](loc11: u64)

7MoveLoc[3](Arg3: u64)

8StLoc[23](loc12: u64)

9VecPack(28, 0)

10StLoc[24](loc13: vector<vector<u8>>)

11MoveLoc[4](Arg4: u64)

12StLoc[25](loc14: u64)

13MoveLoc[5](Arg5: u64)

14StLoc[26](loc15: u64)

15MoveLoc[6](Arg6: bool)

16StLoc[27](loc16: bool)

17MoveLoc[7](Arg7: bool)

18StLoc[28](loc17: bool)

19MoveLoc[1](Arg1: u64)

20StLoc[12](loc1: u64)

21CopyLoc[8](Arg8: address)

22StLoc[13](loc2: address)

23MoveLoc[9](Arg9: bool)

24StLoc[14](loc3: bool)

25CopyLoc[10](Arg10: &mut TxContext)

26Call table_vec::empty<address>(&mut TxContext): TableVec<address>

27StLoc[15](loc4: TableVec<address>)

28CopyLoc[10](Arg10: &mut TxContext)

29Call table::new<address, u64>(&mut TxContext): Table<address, u64>

30StLoc[16](loc5: Table<address, u64>)

31CopyLoc[10](Arg10: &mut TxContext)

32Call table::new<address, Permission>(&mut TxContext): Table<address, Permission>

33StLoc[17](loc6: Table<address, Permission>)

34CopyLoc[10](Arg10: &mut TxContext)

35Call table::new<address, Balance<Ty0>>(&mut TxContext): Table<address, Balance<Ty0>>

36StLoc[19](loc8: Table<address, Balance<Ty0>>)

37Call switchboard::version(): u64

38StLoc[20](loc9: u64)

39MoveLoc[11](loc0: UID)

40MoveLoc[18](loc7: address)

41MoveLoc[22](loc11: u64)

42MoveLoc[23](loc12: u64)

43MoveLoc[24](loc13: vector<vector<u8>>)

44MoveLoc[25](loc14: u64)

45MoveLoc[26](loc15: u64)

46MoveLoc[27](loc16: bool)

47MoveLoc[28](loc17: bool)

48MoveLoc[13](loc2: address)

49MoveLoc[14](loc3: bool)

50MoveLoc[12](loc1: u64)

51LdU64(0)

52LdU64(0)

53LdU64(0)

54LdU64(0)

55MoveLoc[15](loc4: TableVec<address>)

56MoveLoc[16](loc5: Table<address, u64>)

57MoveLoc[17](loc6: Table<address, Permission>)

58MoveLoc[19](loc8: Table<address, Balance<Ty0>>)

59MoveLoc[20](loc9: u64)

60PackGeneric[0](ServiceQueue<Ty0>)

61StLoc[29](loc18: ServiceQueue<Ty0>)

62CopyLoc[8](Arg8: address)

63LdConst[0](address: 0x00..)

64Eq

65BrFalse(71)

B1:

66MoveLoc[10](Arg10: &mut TxContext)

67FreezeRef

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

69StLoc[21](loc10: address)

70Branch(75)

B2:

71MoveLoc[10](Arg10: &mut TxContext)

72Pop

73MoveLoc[8](Arg8: address)

74StLoc[21](loc10: address)

B3:

75MoveLoc[21](loc10: address)

76MutBorrowLoc[29](loc18: ServiceQueue<Ty0>)

77MutBorrowFieldGeneric[9](ServiceQueue.verifier_queue_addr: address)

78WriteRef

79MoveLoc[29](loc18: ServiceQueue<Ty0>)

80Ret

}

public(friend) next<Ty0>(Arg0: &mut ServiceQueue<Ty0>): bool * address {

L1: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

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

12ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

13Call table_vec::length<address>(&TableVec<address>): u64

14LdU64(0)

15Eq

16BrFalse(22)

B4:

17MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

18Pop

19LdFalse

20LdConst[0](address: 0x00..)

21Ret

B5:

22CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

23ImmBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

24ReadRef

25StLoc[1](loc0: u64)

26CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

27ImmBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

28ReadRef

29LdU64(1)

30Add

31CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

32MutBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

33WriteRef

34CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

35ImmBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

36ReadRef

37CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

38ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

39Call table_vec::length<address>(&TableVec<address>): u64

40Mod

41CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

42MutBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

43WriteRef

44LdTrue

45MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

46ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

47MoveLoc[1](loc0: u64)

48Call table_vec::borrow<address>(&TableVec<address>, u64): &address

49ReadRef

50Ret

}

public(friend) share_service_queue<Ty0>(Arg0: ServiceQueue<Ty0>) {

B0:

0MoveLoc[0](Arg0: ServiceQueue<Ty0>)

1Call transfer::share_object<ServiceQueue<Ty0>>(ServiceQueue<Ty0>)

2Ret

}

public(friend) next_garbage_collection_node<Ty0>(Arg0: &mut ServiceQueue<Ty0>): address * u64 {

L1: loc0: address

L2: loc1: u64

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

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

12ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

13Call table_vec::length<address>(&TableVec<address>): u64

14LdU64(1)

15Le

16BrFalse(22)

B4:

17MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

18Pop

19LdConst[0](address: 0x00..)

20LdU64(0)

21Ret

B5:

22CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

23ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

24CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

25ImmBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

26ReadRef

27Call table_vec::borrow<address>(&TableVec<address>, u64): &address

28ReadRef

29StLoc[1](loc0: address)

30CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

31ImmBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

32ReadRef

33StLoc[2](loc1: u64)

34CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

35ImmBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

36ReadRef

37LdU64(1)

38Add

39CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

40MutBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

41WriteRef

42CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

43ImmBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

44ReadRef

45CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

46ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

47Call table_vec::length<address>(&TableVec<address>): u64

48Mod

49MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

50MutBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

51WriteRef

52MoveLoc[1](loc0: address)

53MoveLoc[2](loc1: u64)

54Ret

}

public(friend) garbage_collect<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: u64) {

L2: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

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

12MutBorrowFieldGeneric[18](ServiceQueue.heartbeats: Table<address, u64>)

13CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

14ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

15CopyLoc[1](Arg1: u64)

16Call table_vec::borrow<address>(&TableVec<address>, u64): &address

17ReadRef

18Call table::remove<address, u64>(&mut Table<address, u64>, address): u64

19Pop

20CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

21MutBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

22MoveLoc[1](Arg1: u64)

23Call utils::swap_remove<address>(&mut TableVec<address>, u64)

24CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

25ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

26Call table_vec::length<address>(&TableVec<address>): u64

27StLoc[2](loc0: u64)

28CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

29ImmBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

30ReadRef

31CopyLoc[2](loc0: u64)

32Mod

33CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

34MutBorrowFieldGeneric[16](ServiceQueue.curr_idx: u64)

35WriteRef

36CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

37ImmBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

38ReadRef

39MoveLoc[2](loc0: u64)

40Mod

41MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

42MutBorrowFieldGeneric[17](ServiceQueue.gc_idx: u64)

43WriteRef

44Ret

}

public(friend) push_back<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: address, Arg2: u64) {

L3: loc0: &mut u64

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

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

12ImmBorrowFieldGeneric[18](ServiceQueue.heartbeats: Table<address, u64>)

13CopyLoc[1](Arg1: address)

14Call table::contains<address, u64>(&Table<address, u64>, address): bool

15BrFalse(29)

B4:

16CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

17MutBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

18CopyLoc[1](Arg1: address)

19Call table_vec::push_back<address>(&mut TableVec<address>, address)

20CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

21MutBorrowFieldGeneric[18](ServiceQueue.heartbeats: Table<address, u64>)

22MoveLoc[1](Arg1: address)

23Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64

24StLoc[3](loc0: &mut u64)

25CopyLoc[2](Arg2: u64)

26MoveLoc[3](loc0: &mut u64)

27WriteRef

28Branch(34)

B5:

29CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

30MutBorrowFieldGeneric[18](ServiceQueue.heartbeats: Table<address, u64>)

31MoveLoc[1](Arg1: address)

32CopyLoc[2](Arg2: u64)

33Call table::add<address, u64>(&mut Table<address, u64>, address, u64)

B6:

34MoveLoc[2](Arg2: u64)

35MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

36MutBorrowFieldGeneric[11](ServiceQueue.last_hb: u64)

37WriteRef

38Ret

}

public(friend) increment_node_idx<Ty0>(Arg0: &mut ServiceQueue<Ty0>) {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

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

12ImmBorrowFieldGeneric[12](ServiceQueue.node_idx: u64)

13ReadRef

14LdU64(1)

15Add

16CopyLoc[0](Arg0: &mut ServiceQueue<Ty0>)

17ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

18Call table_vec::length<address>(&TableVec<address>): u64

19Mod

20MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

21MutBorrowFieldGeneric[12](ServiceQueue.node_idx: u64)

22WriteRef

23Ret

}

public node_at_idx<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: u64): address {

B0:

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

1ImmBorrowFieldGeneric[13](ServiceQueue.data: TableVec<address>)

2MoveLoc[1](Arg1: u64)

3Call table_vec::borrow<address>(&TableVec<address>, u64): &address

4ReadRef

5Ret

}

public is_expired<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: address, Arg2: u64): bool {

B0:

0MoveLoc[2](Arg2: u64)

1CopyLoc[0](Arg0: &ServiceQueue<Ty0>)

2ImmBorrowFieldGeneric[18](ServiceQueue.heartbeats: Table<address, u64>)

3MoveLoc[1](Arg1: address)

4Call table::borrow<address, u64>(&Table<address, u64>, address): &u64

5ReadRef

6Sub

7MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

8ImmBorrowFieldGeneric[3](ServiceQueue.node_timeout: u64)

9ReadRef

10Gt

11Ret

}

public(friend) escrow_deposit<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: address, Arg2: Coin<Ty0>) {

L3: loc0: Balance<Ty0>

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

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

12ImmBorrowFieldGeneric[19](ServiceQueue.escrows: Table<address, Balance<Ty0>>)

13CopyLoc[1](Arg1: address)

14Call table::contains<address, Balance<Ty0>>(&Table<address, Balance<Ty0>>, address): bool

15Not

16BrFalse(28)

B4:

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

18StLoc[3](loc0: Balance<Ty0>)

19MutBorrowLoc[3](loc0: Balance<Ty0>)

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

21Call coin::put<Ty0>(&mut Balance<Ty0>, Coin<Ty0>)

22MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

23MutBorrowFieldGeneric[19](ServiceQueue.escrows: Table<address, Balance<Ty0>>)

24MoveLoc[1](Arg1: address)

25MoveLoc[3](loc0: Balance<Ty0>)

26Call table::add<address, Balance<Ty0>>(&mut Table<address, Balance<Ty0>>, address, Balance<Ty0>)

27Branch(34)

B5:

28MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

29MutBorrowFieldGeneric[19](ServiceQueue.escrows: Table<address, Balance<Ty0>>)

30MoveLoc[1](Arg1: address)

31Call table::borrow_mut<address, Balance<Ty0>>(&mut Table<address, Balance<Ty0>>, address): &mut Balance<Ty0>

32MoveLoc[2](Arg2: Coin<Ty0>)

33Call coin::put<Ty0>(&mut Balance<Ty0>, Coin<Ty0>)

B6:

34Ret

}

public(friend) escrow_withdraw<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: address, Arg2: u64, Arg3: &mut TxContext): Coin<Ty0> {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(13)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

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

10Pop

11Call errors::InvalidVersion(): u64

12Abort

B3:

13MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

14MutBorrowFieldGeneric[19](ServiceQueue.escrows: Table<address, Balance<Ty0>>)

15MoveLoc[1](Arg1: address)

16Call table::borrow_mut<address, Balance<Ty0>>(&mut Table<address, Balance<Ty0>>, address): &mut Balance<Ty0>

17MoveLoc[2](Arg2: u64)

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

19Call coin::take<Ty0>(&mut Balance<Ty0>, u64, &mut TxContext): Coin<Ty0>

20Ret

}

public escrow_balance<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: address): u64 {

L2: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[19](ServiceQueue.escrows: Table<address, Balance<Ty0>>)

2CopyLoc[1](Arg1: address)

3Call table::contains<address, Balance<Ty0>>(&Table<address, Balance<Ty0>>, address): bool

4Not

5BrFalse(11)

B1:

6MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

7Pop

8LdU64(0)

9StLoc[2](loc0: u64)

10Branch(17)

B2:

11MoveLoc[0](Arg0: &ServiceQueue<Ty0>)

12ImmBorrowFieldGeneric[19](ServiceQueue.escrows: Table<address, Balance<Ty0>>)

13MoveLoc[1](Arg1: address)

14Call table::borrow<address, Balance<Ty0>>(&Table<address, Balance<Ty0>>, address): &Balance<Ty0>

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

16StLoc[2](loc0: u64)

B3:

17MoveLoc[2](loc0: u64)

18Ret

}

public permission<Ty0>(Arg0: &ServiceQueue<Ty0>, Arg1: address): &Permission {

B0:

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

1ImmBorrowFieldGeneric[20](ServiceQueue.permissions: Table<address, Permission>)

2MoveLoc[1](Arg1: address)

3Call table::borrow<address, Permission>(&Table<address, Permission>, address): &Permission

4Ret

}

public(friend) permission_mut<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: address): &mut Permission {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

11MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

12MutBorrowFieldGeneric[20](ServiceQueue.permissions: Table<address, Permission>)

13MoveLoc[1](Arg1: address)

14Call table::borrow_mut<address, Permission>(&mut Table<address, Permission>, address): &mut Permission

15Ret

}

public(friend) permission_create<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: Permission) {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Eq

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidVersion(): u64

10Abort

B3:

11MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

12MutBorrowFieldGeneric[20](ServiceQueue.permissions: Table<address, Permission>)

13ImmBorrowLoc[1](Arg1: Permission)

14Call permission::key_from_permission(&Permission): address

15MoveLoc[1](Arg1: Permission)

16Call table::add<address, Permission>(&mut Table<address, Permission>, address, Permission)

17Ret

}

entry migrate<Ty0>(Arg0: &mut ServiceQueue<Ty0>, Arg1: &AdminCap) {

B0:

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

1ImmBorrowFieldGeneric[0](ServiceQueue.version: u64)

2ReadRef

3Call switchboard::version(): u64

4Lt

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

8Pop

9Call errors::InvalidPackage(): u64

10Abort

B3:

11Call switchboard::version(): u64

12MoveLoc[0](Arg0: &mut ServiceQueue<Ty0>)

13MutBorrowFieldGeneric[0](ServiceQueue.version: u64)

14WriteRef

15Ret

}

Constants [

0 => address: 0x0000000000000000000000000000000000000000000000000000000000000000

]

}