auction

Module0x5580…2003

Move path: 0xd22b…08f0::auction
Functions: 108 public, 0 entry
Structs: 7
Friend modules: None

auction

Bytecode699 lines

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

// Move bytecode v7

module d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0.auction {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::linked_table;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::sui;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::core_config;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::domain;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::pricing_config;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::registry;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins_registration;

struct App has drop {

dummy_field: bool

}

struct AuctionHouse has store, key {

id: UID,

balance: Balance<SUI>,

auctions: LinkedTable<Domain, Auction>

}

struct Auction has store {

domain: Domain,

start_timestamp_ms: u64,

end_timestamp_ms: u64,

winner: address,

current_bid: Coin<SUI>,

nft: SuinsRegistration

}

struct AuctionStartedEvent has copy, drop {

domain: Domain,

start_timestamp_ms: u64,

end_timestamp_ms: u64,

starting_bid: u64,

bidder: address

}

struct AuctionFinalizedEvent has copy, drop {

domain: Domain,

start_timestamp_ms: u64,

end_timestamp_ms: u64,

winning_bid: u64,

winner: address

}

struct BidEvent has copy, drop {

domain: Domain,

bid: u64,

bidder: address

}

struct AuctionExtendedEvent has copy, drop {

domain: Domain,

end_timestamp_ms: u64

}

init(Arg0: &mut TxContext) {

B0:

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

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

2Call balance::zero<SUI>(): Balance<SUI>

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

4Call linked_table::new<Domain, Auction>(&mut TxContext): LinkedTable<Domain, Auction>

5Pack[1](AuctionHouse)

6Call transfer::share_object<AuctionHouse>(AuctionHouse)

7Ret

}

public start_auction_and_place_bid(Arg0: &mut AuctionHouse, Arg1: &mut SuiNS, Arg2: String, Arg3: Coin<SUI>, Arg4: &Clock, Arg5: &mut TxContext) {

L6: loc0: Auction

L7: loc1: Domain

L8: loc2: u64

L9: loc3: SuinsRegistration

L10: loc4: u64

B0:

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

1FreezeRef

2Call suins::assert_app_is_authorized<App>(&SuiNS)

3MoveLoc[2](Arg2: String)

4Call domain::new(String): Domain

5StLoc[7](loc1: Domain)

6CopyLoc[1](Arg1: &mut SuiNS)

7FreezeRef

8Call suins::get_config<CoreConfig>(&SuiNS): &CoreConfig

9ImmBorrowLoc[7](loc1: Domain)

10Call core_config::assert_is_valid_for_sale(&CoreConfig, &Domain)

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

12ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

13CopyLoc[7](loc1: Domain)

14Call linked_table::contains<Domain, Auction>(&LinkedTable<Domain, Auction>, Domain): bool

15Not

16BrFalse(18)

B1:

17Branch(28)

B2:

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

19Pop

20MoveLoc[0](Arg0: &mut AuctionHouse)

21Pop

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

23Pop

24MoveLoc[4](Arg4: &Clock)

25Pop

26LdConst[4](u64: 1)

27Abort

B3:

28CopyLoc[1](Arg1: &mut SuiNS)

29FreezeRef

30Call suins::get_config<PricingConfig>(&SuiNS): &PricingConfig

31ImmBorrowLoc[7](loc1: Domain)

32Call domain::sld(&Domain): &String

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

34Call pricing_config::calculate_base_price(&PricingConfig, u64): u64

35StLoc[8](loc2: u64)

36ImmBorrowLoc[3](Arg3: Coin<SUI>)

37Call coin::value<SUI>(&Coin<SUI>): u64

38MoveLoc[8](loc2: u64)

39Ge

40BrFalse(42)

B4:

41Branch(52)

B5:

42MoveLoc[1](Arg1: &mut SuiNS)

43Pop

44MoveLoc[0](Arg0: &mut AuctionHouse)

45Pop

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

47Pop

48MoveLoc[4](Arg4: &Clock)

49Pop

50LdConst[3](u64: 0)

51Abort

B6:

52LdFalse

53Pack[0](App)

54MoveLoc[1](Arg1: &mut SuiNS)

55Call suins::app_registry_mut<App, Registry>(App, &mut SuiNS): &mut Registry

56CopyLoc[7](loc1: Domain)

57LdConst[0](u8: 1)

58CopyLoc[4](Arg4: &Clock)

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

60Call registry::add_record(&mut Registry, Domain, u8, &Clock, &mut TxContext): SuinsRegistration

61StLoc[9](loc3: SuinsRegistration)

62ImmBorrowLoc[3](Arg3: Coin<SUI>)

63Call coin::value<SUI>(&Coin<SUI>): u64

64StLoc[10](loc4: u64)

65CopyLoc[7](loc1: Domain)

66CopyLoc[4](Arg4: &Clock)

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

68MoveLoc[4](Arg4: &Clock)

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

70LdConst[1](u64: 1728..)

71Add

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

73FreezeRef

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

75MoveLoc[3](Arg3: Coin<SUI>)

76MoveLoc[9](loc3: SuinsRegistration)

77Pack[2](Auction)

78StLoc[6](loc0: Auction)

79CopyLoc[7](loc1: Domain)

80ImmBorrowLoc[6](loc0: Auction)

81ImmBorrowField[1](Auction.start_timestamp_ms: u64)

82ReadRef

83ImmBorrowLoc[6](loc0: Auction)

84ImmBorrowField[2](Auction.end_timestamp_ms: u64)

85ReadRef

86MoveLoc[10](loc4: u64)

87ImmBorrowLoc[6](loc0: Auction)

88ImmBorrowField[3](Auction.winner: address)

89ReadRef

90Pack[3](AuctionStartedEvent)

91Call event::emit<AuctionStartedEvent>(AuctionStartedEvent)

92MoveLoc[0](Arg0: &mut AuctionHouse)

93MutBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

94MoveLoc[7](loc1: Domain)

95MoveLoc[6](loc0: Auction)

96Call linked_table::push_front<Domain, Auction>(&mut LinkedTable<Domain, Auction>, Domain, Auction)

97Ret

}

public place_bid(Arg0: &mut AuctionHouse, Arg1: String, Arg2: Coin<SUI>, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: Auction

L6: loc1: u64

L7: loc2: address

L8: loc3: Coin<SUI>

L9: loc4: u64

L10: loc5: Domain

L11: loc6: Domain

L12: loc7: u64

L13: loc8: u64

L14: loc9: SuinsRegistration

L15: loc10: u64

L16: loc11: address

B0:

0MoveLoc[1](Arg1: String)

1Call domain::new(String): Domain

2StLoc[10](loc5: Domain)

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

4FreezeRef

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

6StLoc[7](loc2: address)

7CopyLoc[0](Arg0: &mut AuctionHouse)

8ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

9CopyLoc[10](loc5: Domain)

10Call linked_table::contains<Domain, Auction>(&LinkedTable<Domain, Auction>, Domain): bool

11BrFalse(13)

B1:

12Branch(21)

B2:

13MoveLoc[0](Arg0: &mut AuctionHouse)

14Pop

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

16Pop

17MoveLoc[3](Arg3: &Clock)

18Pop

19LdConst[5](u64: 7)

20Abort

B3:

21CopyLoc[0](Arg0: &mut AuctionHouse)

22MutBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

23MoveLoc[10](loc5: Domain)

24Call linked_table::remove<Domain, Auction>(&mut LinkedTable<Domain, Auction>, Domain): Auction

25Unpack[2](Auction)

26StLoc[14](loc9: SuinsRegistration)

27StLoc[8](loc3: Coin<SUI>)

28StLoc[16](loc11: address)

29StLoc[12](loc7: u64)

30StLoc[15](loc10: u64)

31StLoc[11](loc6: Domain)

32CopyLoc[3](Arg3: &Clock)

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

34CopyLoc[12](loc7: u64)

35Le

36BrFalse(38)

B4:

37Branch(46)

B5:

38MoveLoc[0](Arg0: &mut AuctionHouse)

39Pop

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

41Pop

42MoveLoc[3](Arg3: &Clock)

43Pop

44LdConst[7](u64: 9)

45Abort

B6:

46CopyLoc[7](loc2: address)

47CopyLoc[16](loc11: address)

48Neq

49BrFalse(51)

B7:

50Branch(59)

B8:

51MoveLoc[0](Arg0: &mut AuctionHouse)

52Pop

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

54Pop

55MoveLoc[3](Arg3: &Clock)

56Pop

57LdConst[9](u64: 11)

58Abort

B9:

59ImmBorrowLoc[8](loc3: Coin<SUI>)

60Call coin::value<SUI>(&Coin<SUI>): u64

61StLoc[9](loc4: u64)

62ImmBorrowLoc[2](Arg2: Coin<SUI>)

63Call coin::value<SUI>(&Coin<SUI>): u64

64StLoc[6](loc1: u64)

65CopyLoc[6](loc1: u64)

66MoveLoc[9](loc4: u64)

67Gt

68BrFalse(70)

B10:

69Branch(78)

B11:

70MoveLoc[0](Arg0: &mut AuctionHouse)

71Pop

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

73Pop

74MoveLoc[3](Arg3: &Clock)

75Pop

76LdConst[10](u64: 12)

77Abort

B12:

78MoveLoc[8](loc3: Coin<SUI>)

79MoveLoc[16](loc11: address)

80Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)

81CopyLoc[11](loc6: Domain)

82MoveLoc[6](loc1: u64)

83MoveLoc[7](loc2: address)

84Pack[5](BidEvent)

85Call event::emit<BidEvent>(BidEvent)

86CopyLoc[12](loc7: u64)

87CopyLoc[3](Arg3: &Clock)

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

89Sub

90LdConst[2](u64: 600000)

91Lt

92BrFalse(110)

B13:

93MoveLoc[3](Arg3: &Clock)

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

95LdConst[2](u64: 600000)

96Add

97StLoc[13](loc8: u64)

98CopyLoc[13](loc8: u64)

99ImmBorrowLoc[14](loc9: SuinsRegistration)

100Call suins_registration::expiration_timestamp_ms(&SuinsRegistration): u64

101Lt

102BrFalse(112)

B14:

103MoveLoc[13](loc8: u64)

104StLoc[12](loc7: u64)

105CopyLoc[11](loc6: Domain)

106CopyLoc[12](loc7: u64)

107Pack[6](AuctionExtendedEvent)

108Call event::emit<AuctionExtendedEvent>(AuctionExtendedEvent)

109Branch(112)

B15:

110MoveLoc[3](Arg3: &Clock)

111Pop

B16:

112CopyLoc[11](loc6: Domain)

113MoveLoc[15](loc10: u64)

114MoveLoc[12](loc7: u64)

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

116FreezeRef

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

118MoveLoc[2](Arg2: Coin<SUI>)

119MoveLoc[14](loc9: SuinsRegistration)

120Pack[2](Auction)

121StLoc[5](loc0: Auction)

122MoveLoc[0](Arg0: &mut AuctionHouse)

123MutBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

124MoveLoc[11](loc6: Domain)

125MoveLoc[5](loc0: Auction)

126Call linked_table::push_front<Domain, Auction>(&mut LinkedTable<Domain, Auction>, Domain, Auction)

127Ret

}

public claim(Arg0: &mut AuctionHouse, Arg1: String, Arg2: &Clock, Arg3: &mut TxContext): SuinsRegistration {

L4: loc0: Coin<SUI>

L5: loc1: Domain

L6: loc2: u64

L7: loc3: SuinsRegistration

L8: loc4: u64

L9: loc5: address

B0:

0MoveLoc[1](Arg1: String)

1Call domain::new(String): Domain

2StLoc[5](loc1: Domain)

3CopyLoc[0](Arg0: &mut AuctionHouse)

4MutBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

5CopyLoc[5](loc1: Domain)

6Call linked_table::remove<Domain, Auction>(&mut LinkedTable<Domain, Auction>, Domain): Auction

7Unpack[2](Auction)

8StLoc[7](loc3: SuinsRegistration)

9StLoc[4](loc0: Coin<SUI>)

10StLoc[9](loc5: address)

11StLoc[6](loc2: u64)

12StLoc[8](loc4: u64)

13Pop

14MoveLoc[2](Arg2: &Clock)

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

16CopyLoc[6](loc2: u64)

17Gt

18BrFalse(20)

B1:

19Branch(26)

B2:

20MoveLoc[0](Arg0: &mut AuctionHouse)

21Pop

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

23Pop

24LdConst[6](u64: 8)

25Abort

B3:

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

27FreezeRef

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

29CopyLoc[9](loc5: address)

30Eq

31BrFalse(33)

B4:

32Branch(37)

B5:

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

34Pop

35LdConst[8](u64: 10)

36Abort

B6:

37MoveLoc[5](loc1: Domain)

38MoveLoc[8](loc4: u64)

39MoveLoc[6](loc2: u64)

40ImmBorrowLoc[4](loc0: Coin<SUI>)

41Call coin::value<SUI>(&Coin<SUI>): u64

42MoveLoc[9](loc5: address)

43Pack[4](AuctionFinalizedEvent)

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

45MoveLoc[0](Arg0: &mut AuctionHouse)

46MutBorrowField[4](AuctionHouse.balance: Balance<SUI>)

47MoveLoc[4](loc0: Coin<SUI>)

48Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>

49Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64

50Pop

51MoveLoc[7](loc3: SuinsRegistration)

52Ret

}

public get_auction_metadata(Arg0: &AuctionHouse, Arg1: String): Option<u64> * Option<u64> * Option<address> * Option<u64> {

L2: loc0: &Auction

L3: loc1: Domain

L4: loc2: u64

B0:

0MoveLoc[1](Arg1: String)

1Call domain::new(String): Domain

2StLoc[3](loc1: Domain)

3CopyLoc[0](Arg0: &AuctionHouse)

4ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

5CopyLoc[3](loc1: Domain)

6Call linked_table::contains<Domain, Auction>(&LinkedTable<Domain, Auction>, Domain): bool

7BrFalse(32)

B1:

8MoveLoc[0](Arg0: &AuctionHouse)

9ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

10MoveLoc[3](loc1: Domain)

11Call linked_table::borrow<Domain, Auction>(&LinkedTable<Domain, Auction>, Domain): &Auction

12StLoc[2](loc0: &Auction)

13CopyLoc[2](loc0: &Auction)

14ImmBorrowField[5](Auction.current_bid: Coin<SUI>)

15Call coin::value<SUI>(&Coin<SUI>): u64

16StLoc[4](loc2: u64)

17CopyLoc[2](loc0: &Auction)

18ImmBorrowField[1](Auction.start_timestamp_ms: u64)

19ReadRef

20Call option::some<u64>(u64): Option<u64>

21CopyLoc[2](loc0: &Auction)

22ImmBorrowField[2](Auction.end_timestamp_ms: u64)

23ReadRef

24Call option::some<u64>(u64): Option<u64>

25MoveLoc[2](loc0: &Auction)

26ImmBorrowField[3](Auction.winner: address)

27ReadRef

28Call option::some<address>(address): Option<address>

29MoveLoc[4](loc2: u64)

30Call option::some<u64>(u64): Option<u64>

31Ret

B2:

32MoveLoc[0](Arg0: &AuctionHouse)

33Pop

34Call option::none<u64>(): Option<u64>

35Call option::none<u64>(): Option<u64>

36Call option::none<address>(): Option<address>

37Call option::none<u64>(): Option<u64>

38Ret

}

public collect_winning_auction_fund(Arg0: &mut AuctionHouse, Arg1: String, Arg2: &Clock, Arg3: &mut TxContext) {

L4: loc0: u64

L5: loc1: &mut Auction

L6: loc2: Domain

B0:

0MoveLoc[1](Arg1: String)

1Call domain::new(String): Domain

2StLoc[6](loc2: Domain)

3CopyLoc[0](Arg0: &mut AuctionHouse)

4MutBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

5MoveLoc[6](loc2: Domain)

6Call linked_table::borrow_mut<Domain, Auction>(&mut LinkedTable<Domain, Auction>, Domain): &mut Auction

7StLoc[5](loc1: &mut Auction)

8MoveLoc[2](Arg2: &Clock)

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

10CopyLoc[5](loc1: &mut Auction)

11ImmBorrowField[2](Auction.end_timestamp_ms: u64)

12ReadRef

13Gt

14BrFalse(16)

B1:

15Branch(24)

B2:

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

17Pop

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

19Pop

20MoveLoc[5](loc1: &mut Auction)

21Pop

22LdConst[6](u64: 8)

23Abort

B3:

24CopyLoc[5](loc1: &mut Auction)

25ImmBorrowField[5](Auction.current_bid: Coin<SUI>)

26Call coin::value<SUI>(&Coin<SUI>): u64

27StLoc[4](loc0: u64)

28MoveLoc[0](Arg0: &mut AuctionHouse)

29MutBorrowField[4](AuctionHouse.balance: Balance<SUI>)

30MoveLoc[5](loc1: &mut Auction)

31MutBorrowField[5](Auction.current_bid: Coin<SUI>)

32MoveLoc[4](loc0: u64)

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

34Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>

35Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>

36Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64

37Pop

38Ret

}

public admin_withdraw_funds(Arg0: &AdminCap, Arg1: &mut AuctionHouse, Arg2: &mut TxContext): Coin<SUI> {

L3: loc0: u64

B0:

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

1ImmBorrowField[4](AuctionHouse.balance: Balance<SUI>)

2Call balance::value<SUI>(&Balance<SUI>): u64

3StLoc[3](loc0: u64)

4CopyLoc[3](loc0: u64)

5LdU64(0)

6Gt

7BrFalse(9)

B1:

8Branch(15)

B2:

9MoveLoc[1](Arg1: &mut AuctionHouse)

10Pop

11MoveLoc[2](Arg2: &mut TxContext)

12Pop

13LdConst[11](u64: 13)

14Abort

B3:

15MoveLoc[1](Arg1: &mut AuctionHouse)

16MutBorrowField[4](AuctionHouse.balance: Balance<SUI>)

17MoveLoc[3](loc0: u64)

18MoveLoc[2](Arg2: &mut TxContext)

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

20Ret

}

public admin_finalize_auction(Arg0: &AdminCap, Arg1: &mut AuctionHouse, Arg2: String, Arg3: &Clock) {

L4: loc0: Domain

B0:

0MoveLoc[2](Arg2: String)

1Call domain::new(String): Domain

2StLoc[4](loc0: Domain)

3MoveLoc[0](Arg0: &AdminCap)

4MoveLoc[1](Arg1: &mut AuctionHouse)

5MoveLoc[4](loc0: Domain)

6MoveLoc[3](Arg3: &Clock)

7Call admin_finalize_auction_internal(&AdminCap, &mut AuctionHouse, Domain, &Clock)

8Ret

}

admin_finalize_auction_internal(Arg0: &AdminCap, Arg1: &mut AuctionHouse, Arg2: Domain, Arg3: &Clock) {

L4: loc0: Coin<SUI>

L5: loc1: u64

L6: loc2: SuinsRegistration

L7: loc3: u64

L8: loc4: address

B0:

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

1MutBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

2CopyLoc[2](Arg2: Domain)

3Call linked_table::remove<Domain, Auction>(&mut LinkedTable<Domain, Auction>, Domain): Auction

4Unpack[2](Auction)

5StLoc[6](loc2: SuinsRegistration)

6StLoc[4](loc0: Coin<SUI>)

7StLoc[8](loc4: address)

8StLoc[5](loc1: u64)

9StLoc[7](loc3: u64)

10Pop

11MoveLoc[3](Arg3: &Clock)

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

13CopyLoc[5](loc1: u64)

14Gt

15BrFalse(17)

B1:

16Branch(21)

B2:

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

18Pop

19LdConst[6](u64: 8)

20Abort

B3:

21MoveLoc[2](Arg2: Domain)

22MoveLoc[7](loc3: u64)

23MoveLoc[5](loc1: u64)

24ImmBorrowLoc[4](loc0: Coin<SUI>)

25Call coin::value<SUI>(&Coin<SUI>): u64

26CopyLoc[8](loc4: address)

27Pack[4](AuctionFinalizedEvent)

28Call event::emit<AuctionFinalizedEvent>(AuctionFinalizedEvent)

29MoveLoc[1](Arg1: &mut AuctionHouse)

30MutBorrowField[4](AuctionHouse.balance: Balance<SUI>)

31MoveLoc[4](loc0: Coin<SUI>)

32Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>

33Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64

34Pop

35MoveLoc[6](loc2: SuinsRegistration)

36MoveLoc[8](loc4: address)

37Call transfer::public_transfer<SuinsRegistration>(SuinsRegistration, address)

38Ret

}

public admin_try_finalize_auctions(Arg0: &AdminCap, Arg1: &mut AuctionHouse, Arg2: u64, Arg3: &Clock) {

L4: loc0: &Auction

L5: loc1: Domain

L6: loc2: Option<Domain>

B0:

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

1ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

2Call linked_table::back<Domain, Auction>(&LinkedTable<Domain, Auction>): &Option<Domain>

3ReadRef

4StLoc[6](loc2: Option<Domain>)

B1:

5ImmBorrowLoc[6](loc2: Option<Domain>)

6Call option::is_some<Domain>(&Option<Domain>): bool

7BrFalse(51)

B2:

8Branch(9)

B3:

9CopyLoc[2](Arg2: u64)

10LdU64(0)

11Eq

12BrFalse(20)

B4:

13MoveLoc[1](Arg1: &mut AuctionHouse)

14Pop

15MoveLoc[3](Arg3: &Clock)

16Pop

17MoveLoc[0](Arg0: &AdminCap)

18Pop

19Ret

B5:

20MoveLoc[2](Arg2: u64)

21LdU64(1)

22Sub

23StLoc[2](Arg2: u64)

24MutBorrowLoc[6](loc2: Option<Domain>)

25Call option::extract<Domain>(&mut Option<Domain>): Domain

26StLoc[5](loc1: Domain)

27CopyLoc[1](Arg1: &mut AuctionHouse)

28ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

29CopyLoc[5](loc1: Domain)

30Call linked_table::prev<Domain, Auction>(&LinkedTable<Domain, Auction>, Domain): &Option<Domain>

31ReadRef

32StLoc[6](loc2: Option<Domain>)

33CopyLoc[1](Arg1: &mut AuctionHouse)

34ImmBorrowField[0](AuctionHouse.auctions: LinkedTable<Domain, Auction>)

35CopyLoc[5](loc1: Domain)

36Call linked_table::borrow<Domain, Auction>(&LinkedTable<Domain, Auction>, Domain): &Auction

37StLoc[4](loc0: &Auction)

38CopyLoc[3](Arg3: &Clock)

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

40MoveLoc[4](loc0: &Auction)

41ImmBorrowField[2](Auction.end_timestamp_ms: u64)

42ReadRef

43Gt

44BrFalse(5)

B6:

45CopyLoc[0](Arg0: &AdminCap)

46CopyLoc[1](Arg1: &mut AuctionHouse)

47MoveLoc[5](loc1: Domain)

48CopyLoc[3](Arg3: &Clock)

49Call admin_finalize_auction_internal(&AdminCap, &mut AuctionHouse, Domain, &Clock)

50Branch(5)

B7:

51MoveLoc[1](Arg1: &mut AuctionHouse)

52Pop

53MoveLoc[3](Arg3: &Clock)

54Pop

55MoveLoc[0](Arg0: &AdminCap)

56Pop

57Ret

}

Constants [

0 => u8: 1

1 => u64: 172800000

2 => u64: 600000

3 => u64: 0

4 => u64: 1

5 => u64: 7

6 => u64: 8

7 => u64: 9

8 => u64: 10

9 => u64: 11

10 => u64: 12

11 => u64: 13

]

}