payment

Module0x5580…2003

Move path: 0xd22b…08f0::payment
Functions: 1613 public, 0 entry
Structs: 4
Friend modules: None

payment

Bytecode823 lines

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

// Move bytecode v7

module d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0.payment {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::clock;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::constants;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::core_config;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::domain;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::name_record;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::pricing_config;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::registry;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins;

use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins_registration;

struct RequestData has drop {

version: u8,

domain: Domain,

years: u8,

base_amount: u64,

discounts_applied: VecMap<String, u64>,

metadata: VecMap<String, String>

}

struct TransactionEvent has copy, drop, store {

app: TypeName,

domain: Domain,

years: u8,

request_data_version: u8,

base_amount: u64,

discounts_applied: VecMap<String, u64>,

metadata: VecMap<String, String>,

is_renewal: bool,

currency: TypeName,

currency_amount: u64

}

enum PaymentIntent {

Registration { pos0: RequestData },

Renewal { pos0: RequestData }

}

enum Receipt {

Registration { domain: Domain, years: u8, version: u8 },

Renewal { domain: Domain, years: u8, version: u8 }

}

public apply_percentage_discount<Ty0: drop>(Arg0: &mut PaymentIntent, Arg1: &mut SuiNS, Arg2: Ty0, Arg3: String, Arg4: u8, Arg5: bool) {

L6: loc0: &PaymentIntent

L7: loc1: &mut PaymentIntent

B0:

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

1FreezeRef

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

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

4StLoc[7](loc1: &mut PaymentIntent)

5CopyLoc[7](loc1: &mut PaymentIntent)

6FreezeRef

7StLoc[6](loc0: &PaymentIntent)

8CopyLoc[6](loc0: &PaymentIntent)

9VariantSwitch(VariantJumpTableIndex(0))

B1:

10MoveLoc[6](loc0: &PaymentIntent)

11UnpackVariantImmRef(VariantHandleIndex(0))

12Pop

13MoveLoc[7](loc1: &mut PaymentIntent)

14UnpackVariantMutRef(VariantHandleIndex(0))

15MoveLoc[3](Arg3: String)

16MoveLoc[4](Arg4: u8)

17MoveLoc[5](Arg5: bool)

18Call adjust_discount(&mut RequestData, String, u8, bool)

19Branch(29)

B2:

20MoveLoc[6](loc0: &PaymentIntent)

21UnpackVariantImmRef(VariantHandleIndex(1))

22Pop

23MoveLoc[7](loc1: &mut PaymentIntent)

24UnpackVariantMutRef(VariantHandleIndex(1))

25MoveLoc[3](Arg3: String)

26MoveLoc[4](Arg4: u8)

27MoveLoc[5](Arg5: bool)

28Call adjust_discount(&mut RequestData, String, u8, bool)

B3:

29Ret

Jump tables:

[0]: variant_switch PaymentIntent {

Variant0 => jump 10

Variant1 => jump 20

}

public finalize_payment<Ty0: drop, Ty1>(Arg0: PaymentIntent, Arg1: &mut SuiNS, Arg2: Ty0, Arg3: Coin<Ty1>): Receipt {

L4: loc0: Receipt

L5: loc1: &PaymentIntent

L6: loc2: PaymentIntent

L7: loc3: RequestData

L8: loc4: RequestData

B0:

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

1FreezeRef

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

3ImmBorrowLoc[0](Arg0: PaymentIntent)

4ImmBorrowLoc[3](Arg3: Coin<Ty1>)

5Call coin::value<Ty1>(&Coin<Ty1>): u64

6Call to_event<Ty0, Ty1>(&PaymentIntent, u64): TransactionEvent

7Call event::emit<TransactionEvent>(TransactionEvent)

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

9MoveLoc[2](Arg2: Ty0)

10MoveLoc[3](Arg3: Coin<Ty1>)

11Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>

12Call suins::app_add_custom_balance<Ty0, Ty1>(&mut SuiNS, Ty0, Balance<Ty1>)

13MoveLoc[0](Arg0: PaymentIntent)

14StLoc[6](loc2: PaymentIntent)

15ImmBorrowLoc[6](loc2: PaymentIntent)

16StLoc[5](loc1: &PaymentIntent)

17CopyLoc[5](loc1: &PaymentIntent)

18VariantSwitch(VariantJumpTableIndex(0))

B1:

19MoveLoc[5](loc1: &PaymentIntent)

20UnpackVariantImmRef(VariantHandleIndex(0))

21Pop

22MoveLoc[6](loc2: PaymentIntent)

23UnpackVariant(VariantHandleIndex(0))

24StLoc[7](loc3: RequestData)

25ImmBorrowLoc[7](loc3: RequestData)

26ImmBorrowField[0](RequestData.domain: Domain)

27ReadRef

28ImmBorrowLoc[7](loc3: RequestData)

29ImmBorrowField[1](RequestData.years: u8)

30ReadRef

31ImmBorrowLoc[7](loc3: RequestData)

32ImmBorrowField[2](RequestData.version: u8)

33ReadRef

34PackVariant(VariantHandleIndex(2))

35StLoc[4](loc0: Receipt)

36Branch(54)

B2:

37MoveLoc[5](loc1: &PaymentIntent)

38UnpackVariantImmRef(VariantHandleIndex(1))

39Pop

40MoveLoc[6](loc2: PaymentIntent)

41UnpackVariant(VariantHandleIndex(1))

42StLoc[8](loc4: RequestData)

43ImmBorrowLoc[8](loc4: RequestData)

44ImmBorrowField[0](RequestData.domain: Domain)

45ReadRef

46ImmBorrowLoc[8](loc4: RequestData)

47ImmBorrowField[1](RequestData.years: u8)

48ReadRef

49ImmBorrowLoc[8](loc4: RequestData)

50ImmBorrowField[2](RequestData.version: u8)

51ReadRef

52PackVariant(VariantHandleIndex(3))

53StLoc[4](loc0: Receipt)

B3:

54MoveLoc[4](loc0: Receipt)

55Ret

Jump tables:

[0]: variant_switch PaymentIntent {

Variant0 => jump 19

Variant1 => jump 37

}

public init_registration(Arg0: &mut SuiNS, Arg1: String): PaymentIntent {

L2: loc0: Domain

L3: loc1: u64

L4: loc2: VecMap<String, u64>

L5: loc3: VecMap<String, String>

L6: loc4: Domain

L7: loc5: u64

B0:

0MoveLoc[1](Arg1: String)

1Call domain::new(String): Domain

2StLoc[6](loc4: Domain)

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

4FreezeRef

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

6ImmBorrowLoc[6](loc4: Domain)

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

8MoveLoc[0](Arg0: &mut SuiNS)

9FreezeRef

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

11ImmBorrowLoc[6](loc4: Domain)

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

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

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

15StLoc[7](loc5: u64)

16MoveLoc[6](loc4: Domain)

17StLoc[2](loc0: Domain)

18MoveLoc[7](loc5: u64)

19StLoc[3](loc1: u64)

20Call vec_map::empty<String, u64>(): VecMap<String, u64>

21StLoc[4](loc2: VecMap<String, u64>)

22Call vec_map::empty<String, String>(): VecMap<String, String>

23StLoc[5](loc3: VecMap<String, String>)

24LdU8(1)

25MoveLoc[2](loc0: Domain)

26LdU8(1)

27MoveLoc[3](loc1: u64)

28MoveLoc[4](loc2: VecMap<String, u64>)

29MoveLoc[5](loc3: VecMap<String, String>)

30Pack[0](RequestData)

31PackVariant(VariantHandleIndex(0))

32Ret

}

public init_renewal(Arg0: &mut SuiNS, Arg1: &SuinsRegistration, Arg2: u8): PaymentIntent {

L3: loc0: Domain

L4: loc1: u8

L5: loc2: u64

L6: loc3: VecMap<String, u64>

L7: loc4: VecMap<String, String>

L8: loc5: Domain

L9: loc6: u64

B0:

0MoveLoc[1](Arg1: &SuinsRegistration)

1Call suins_registration::domain(&SuinsRegistration): Domain

2StLoc[8](loc5: Domain)

3ImmBorrowLoc[8](loc5: Domain)

4Call domain::is_subdomain(&Domain): bool

5Not

6BrFalse(8)

B1:

7Branch(12)

B2:

8MoveLoc[0](Arg0: &mut SuiNS)

9Pop

10LdU64(13906835033337757711)

11Abort

B3:

12CopyLoc[2](Arg2: u8)

13CopyLoc[0](Arg0: &mut SuiNS)

14FreezeRef

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

16Call core_config::max_years(&CoreConfig): u8

17Le

18BrFalse(20)

B4:

19Branch(24)

B5:

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

21Pop

22LdU64(13906835037632987155)

23Abort

B6:

24MoveLoc[0](Arg0: &mut SuiNS)

25FreezeRef

26Call suins::get_config<RenewalConfig>(&SuiNS): &RenewalConfig

27Call pricing_config::config(&RenewalConfig): &PricingConfig

28ImmBorrowLoc[8](loc5: Domain)

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

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

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

32StLoc[9](loc6: u64)

33MoveLoc[8](loc5: Domain)

34StLoc[3](loc0: Domain)

35CopyLoc[2](Arg2: u8)

36StLoc[4](loc1: u8)

37MoveLoc[9](loc6: u64)

38MoveLoc[2](Arg2: u8)

39CastU64

40Mul

41StLoc[5](loc2: u64)

42Call vec_map::empty<String, u64>(): VecMap<String, u64>

43StLoc[6](loc3: VecMap<String, u64>)

44Call vec_map::empty<String, String>(): VecMap<String, String>

45StLoc[7](loc4: VecMap<String, String>)

46LdU8(1)

47MoveLoc[3](loc0: Domain)

48MoveLoc[4](loc1: u8)

49MoveLoc[5](loc2: u64)

50MoveLoc[6](loc3: VecMap<String, u64>)

51MoveLoc[7](loc4: VecMap<String, String>)

52Pack[0](RequestData)

53PackVariant(VariantHandleIndex(1))

54Ret

}

public register(Arg0: Receipt, Arg1: &mut SuiNS, Arg2: &Clock, Arg3: &mut TxContext): SuinsRegistration {

L4: loc0: &Receipt

L5: loc1: Receipt

L6: loc2: u8

L7: loc3: u8

L8: loc4: &CoreConfig

L9: loc5: Domain

L10: loc6: u8

B0:

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

1FreezeRef

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

3StLoc[8](loc4: &CoreConfig)

4MoveLoc[0](Arg0: Receipt)

5StLoc[5](loc1: Receipt)

6ImmBorrowLoc[5](loc1: Receipt)

7StLoc[4](loc0: &Receipt)

8CopyLoc[4](loc0: &Receipt)

9VariantSwitch(VariantJumpTableIndex(0))

B1:

10MoveLoc[4](loc0: &Receipt)

11UnpackVariantImmRef(VariantHandleIndex(2))

12Pop

13Pop

14Pop

15MoveLoc[5](loc1: Receipt)

16UnpackVariant(VariantHandleIndex(2))

17StLoc[6](loc2: u8)

18StLoc[7](loc3: u8)

19StLoc[9](loc5: Domain)

20MoveLoc[7](loc3: u8)

21StLoc[10](loc6: u8)

22MoveLoc[6](loc2: u8)

23CopyLoc[8](loc4: &CoreConfig)

24Call core_config::payments_version(&CoreConfig): u8

25Eq

26BrFalse(28)

B2:

27Branch(58)

B3:

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

29Pop

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

31Pop

32MoveLoc[8](loc4: &CoreConfig)

33Pop

34MoveLoc[2](Arg2: &Clock)

35Pop

36LdU64(13906835162186514443)

37Abort

B4:

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

39Pop

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

41Pop

42MoveLoc[8](loc4: &CoreConfig)

43Pop

44MoveLoc[2](Arg2: &Clock)

45Pop

46MoveLoc[4](loc0: &Receipt)

47UnpackVariantImmRef(VariantHandleIndex(3))

48Pop

49Pop

50Pop

51MoveLoc[5](loc1: Receipt)

52UnpackVariant(VariantHandleIndex(3))

53Pop

54Pop

55Pop

56LdU64(13906835183660826627)

57Abort

B5:

58MoveLoc[8](loc4: &CoreConfig)

59ImmBorrowLoc[9](loc5: Domain)

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

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

62Call suins::pkg_registry_mut<Registry>(&mut SuiNS): &mut Registry

63MoveLoc[9](loc5: Domain)

64MoveLoc[10](loc6: u8)

65MoveLoc[2](Arg2: &Clock)

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

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

68Ret

Jump tables:

[0]: variant_switch Receipt {

Variant0 => jump 10

Variant1 => jump 38

}

public renew(Arg0: Receipt, Arg1: &mut SuiNS, Arg2: &mut SuinsRegistration, Arg3: &Clock, Arg4: &mut TxContext) {

L5: loc0: &Receipt

L6: loc1: Receipt

L7: loc2: u8

L8: loc3: u8

L9: loc4: &CoreConfig

L10: loc5: Domain

L11: loc6: u8

L12: loc7: &mut Registry

L13: loc8: u64

L14: loc9: u8

L15: loc10: u8

B0:

0MoveLoc[0](Arg0: Receipt)

1StLoc[6](loc1: Receipt)

2ImmBorrowLoc[6](loc1: Receipt)

3StLoc[5](loc0: &Receipt)

4CopyLoc[5](loc0: &Receipt)

5VariantSwitch(VariantJumpTableIndex(0))

B1:

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

7Pop

8MoveLoc[2](Arg2: &mut SuinsRegistration)

9Pop

10MoveLoc[3](Arg3: &Clock)

11Pop

12MoveLoc[5](loc0: &Receipt)

13UnpackVariantImmRef(VariantHandleIndex(2))

14Pop

15Pop

16Pop

17MoveLoc[6](loc1: Receipt)

18UnpackVariant(VariantHandleIndex(2))

19Pop

20Pop

21Pop

22LdU64(13906835381229322243)

23Abort

B2:

24MoveLoc[5](loc0: &Receipt)

25UnpackVariantImmRef(VariantHandleIndex(3))

26Pop

27Pop

28Pop

29MoveLoc[6](loc1: Receipt)

30UnpackVariant(VariantHandleIndex(3))

31StLoc[7](loc2: u8)

32StLoc[8](loc3: u8)

33StLoc[10](loc5: Domain)

34MoveLoc[8](loc3: u8)

35StLoc[15](loc10: u8)

36MoveLoc[7](loc2: u8)

37StLoc[14](loc9: u8)

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

39FreezeRef

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

41StLoc[9](loc4: &CoreConfig)

42CopyLoc[9](loc4: &CoreConfig)

43Call core_config::max_years(&CoreConfig): u8

44StLoc[11](loc6: u8)

45MoveLoc[14](loc9: u8)

46MoveLoc[9](loc4: &CoreConfig)

47Call core_config::payments_version(&CoreConfig): u8

48Eq

49BrFalse(51)

B3:

50Branch(59)

B4:

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

52Pop

53MoveLoc[2](Arg2: &mut SuinsRegistration)

54Pop

55MoveLoc[3](Arg3: &Clock)

56Pop

57LdU64(13906835265265729547)

58Abort

B5:

59CopyLoc[2](Arg2: &mut SuinsRegistration)

60FreezeRef

61Call suins_registration::domain(&SuinsRegistration): Domain

62CopyLoc[10](loc5: Domain)

63Eq

64BrFalse(66)

B6:

65Branch(74)

B7:

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

67Pop

68MoveLoc[2](Arg2: &mut SuinsRegistration)

69Pop

70MoveLoc[3](Arg3: &Clock)

71Pop

72LdU64(13906835269560565769)

73Abort

B8:

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

75Call suins::pkg_registry_mut<Registry>(&mut SuiNS): &mut Registry

76StLoc[12](loc7: &mut Registry)

77CopyLoc[12](loc7: &mut Registry)

78FreezeRef

79CopyLoc[10](loc5: Domain)

80CopyLoc[3](Arg3: &Clock)

81MoveLoc[15](loc10: u8)

82Call target_expiration(&Registry, Domain, &Clock, u8): u64

83StLoc[13](loc8: u64)

84CopyLoc[13](loc8: u64)

85MoveLoc[3](Arg3: &Clock)

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

87MoveLoc[11](loc6: u8)

88LdU8(1)

89Add

90CastU64

91Call constants::year_ms(): u64

92Mul

93Add

94Le

95BrFalse(97)

B9:

96Branch(103)

B10:

97MoveLoc[12](loc7: &mut Registry)

98Pop

99MoveLoc[2](Arg2: &mut SuinsRegistration)

100Pop

101LdU64(13906835338280697875)

102Abort

B11:

103MoveLoc[12](loc7: &mut Registry)

104MoveLoc[2](Arg2: &mut SuinsRegistration)

105MoveLoc[10](loc5: Domain)

106MoveLoc[13](loc8: u64)

107Call registry::set_expiration_timestamp_ms(&mut Registry, &mut SuinsRegistration, Domain, u64)

108Ret

Jump tables:

[0]: variant_switch Receipt {

Variant0 => jump 6

Variant1 => jump 24

}

public request_data(Arg0: &PaymentIntent): &RequestData {

L1: loc0: &RequestData

L2: loc1: &PaymentIntent

L3: loc2: &PaymentIntent

B0:

0MoveLoc[0](Arg0: &PaymentIntent)

1StLoc[3](loc2: &PaymentIntent)

2CopyLoc[3](loc2: &PaymentIntent)

3StLoc[2](loc1: &PaymentIntent)

4CopyLoc[2](loc1: &PaymentIntent)

5VariantSwitch(VariantJumpTableIndex(0))

B1:

6MoveLoc[2](loc1: &PaymentIntent)

7UnpackVariantImmRef(VariantHandleIndex(0))

8Pop

9MoveLoc[3](loc2: &PaymentIntent)

10UnpackVariantImmRef(VariantHandleIndex(0))

11StLoc[1](loc0: &RequestData)

12Branch(19)

B2:

13MoveLoc[2](loc1: &PaymentIntent)

14UnpackVariantImmRef(VariantHandleIndex(1))

15Pop

16MoveLoc[3](loc2: &PaymentIntent)

17UnpackVariantImmRef(VariantHandleIndex(1))

18StLoc[1](loc0: &RequestData)

B3:

19MoveLoc[1](loc0: &RequestData)

20Ret

Jump tables:

[0]: variant_switch PaymentIntent {

Variant0 => jump 6

Variant1 => jump 13

}

public years(Arg0: &RequestData): u8 {

B0:

0MoveLoc[0](Arg0: &RequestData)

1ImmBorrowField[1](RequestData.years: u8)

2ReadRef

3Ret

}

public base_amount(Arg0: &RequestData): u64 {

B0:

0MoveLoc[0](Arg0: &RequestData)

1ImmBorrowField[3](RequestData.base_amount: u64)

2ReadRef

3Ret

}

public domain(Arg0: &RequestData): &Domain {

B0:

0MoveLoc[0](Arg0: &RequestData)

1ImmBorrowField[0](RequestData.domain: Domain)

2Ret

}

public discount_applied(Arg0: &RequestData): bool {

B0:

0MoveLoc[0](Arg0: &RequestData)

1ImmBorrowField[4](RequestData.discounts_applied: VecMap<String, u64>)

2Call vec_map::size<String, u64>(&VecMap<String, u64>): u64

3LdU64(0)

4Gt

5Ret

}

public discounts_applied(Arg0: &RequestData): VecMap<String, u64> {

B0:

0MoveLoc[0](Arg0: &RequestData)

1ImmBorrowField[4](RequestData.discounts_applied: VecMap<String, u64>)

2ReadRef

3Ret

}

public calculate_total_after_discount(Arg0: &RequestData, Arg1: u8): u64 {

L2: loc0: u64

L3: loc1: u64

B0:

0MoveLoc[0](Arg0: &RequestData)

1ImmBorrowField[3](RequestData.base_amount: u64)

2ReadRef

3StLoc[3](loc1: u64)

4CopyLoc[3](loc1: u64)

5CastU128

6MoveLoc[1](Arg1: u8)

7CastU128

8Mul

9LdU128(100)

10Div

11CastU64

12StLoc[2](loc0: u64)

13MoveLoc[3](loc1: u64)

14MoveLoc[2](loc0: u64)

15Sub

16Ret

}

to_event<Ty0: drop, Ty1>(Arg0: &PaymentIntent, Arg1: u64): TransactionEvent {

L2: loc0: bool

L3: loc1: &PaymentIntent

L4: loc2: &RequestData

L5: loc3: bool

B0:

0CopyLoc[0](Arg0: &PaymentIntent)

1Call request_data(&PaymentIntent): &RequestData

2StLoc[4](loc2: &RequestData)

3MoveLoc[0](Arg0: &PaymentIntent)

4StLoc[3](loc1: &PaymentIntent)

5CopyLoc[3](loc1: &PaymentIntent)

6VariantSwitch(VariantJumpTableIndex(0))

B1:

7MoveLoc[3](loc1: &PaymentIntent)

8UnpackVariantImmRef(VariantHandleIndex(0))

9Pop

10LdFalse

11StLoc[2](loc0: bool)

12Branch(18)

B2:

13MoveLoc[3](loc1: &PaymentIntent)

14UnpackVariantImmRef(VariantHandleIndex(1))

15Pop

16LdTrue

17StLoc[2](loc0: bool)

B3:

18MoveLoc[2](loc0: bool)

19StLoc[5](loc3: bool)

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

21CopyLoc[4](loc2: &RequestData)

22ImmBorrowField[0](RequestData.domain: Domain)

23ReadRef

24CopyLoc[4](loc2: &RequestData)

25ImmBorrowField[1](RequestData.years: u8)

26ReadRef

27CopyLoc[4](loc2: &RequestData)

28ImmBorrowField[2](RequestData.version: u8)

29ReadRef

30CopyLoc[4](loc2: &RequestData)

31ImmBorrowField[3](RequestData.base_amount: u64)

32ReadRef

33CopyLoc[4](loc2: &RequestData)

34ImmBorrowField[4](RequestData.discounts_applied: VecMap<String, u64>)

35ReadRef

36MoveLoc[4](loc2: &RequestData)

37ImmBorrowField[5](RequestData.metadata: VecMap<String, String>)

38ReadRef

39MoveLoc[5](loc3: bool)

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

41MoveLoc[1](Arg1: u64)

42Pack[1](TransactionEvent)

43Ret

Jump tables:

[0]: variant_switch PaymentIntent {

Variant0 => jump 7

Variant1 => jump 13

}

adjust_discount(Arg0: &mut RequestData, Arg1: String, Arg2: u8, Arg3: bool) {

L4: loc0: bool

L5: loc1: u64

L6: loc2: u64

B0:

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

1ImmBorrowField[4](RequestData.discounts_applied: VecMap<String, u64>)

2ImmBorrowLoc[1](Arg1: String)

3Call vec_map::contains<String, u64>(&VecMap<String, u64>, &String): bool

4Not

5BrFalse(7)

B1:

6Branch(11)

B2:

7MoveLoc[0](Arg0: &mut RequestData)

8Pop

9LdU64(13906835673288015889)

10Abort

B3:

11MoveLoc[3](Arg3: bool)

12BrFalse(16)

B4:

13LdTrue

14StLoc[4](loc0: bool)

15Branch(21)

B5:

16CopyLoc[0](Arg0: &mut RequestData)

17FreezeRef

18Call discount_applied(&RequestData): bool

19Not

20StLoc[4](loc0: bool)

B6:

21MoveLoc[4](loc0: bool)

22BrFalse(24)

B7:

23Branch(28)

B8:

24MoveLoc[0](Arg0: &mut RequestData)

25Pop

26LdU64(13906835677581934593)

27Abort

B9:

28CopyLoc[2](Arg2: u8)

29LdU8(100)

30Le

31BrFalse(33)

B10:

32Branch(37)

B11:

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

34Pop

35LdU64(13906835681877688333)

36Abort

B12:

37CopyLoc[0](Arg0: &mut RequestData)

38ImmBorrowField[3](RequestData.base_amount: u64)

39ReadRef

40StLoc[6](loc2: u64)

41CopyLoc[6](loc2: u64)

42CastU128

43CopyLoc[2](Arg2: u8)

44CastU128

45Mul

46LdU128(100)

47Div

48CastU64

49StLoc[5](loc1: u64)

50MoveLoc[6](loc2: u64)

51MoveLoc[5](loc1: u64)

52Sub

53CopyLoc[0](Arg0: &mut RequestData)

54MutBorrowField[3](RequestData.base_amount: u64)

55WriteRef

56MoveLoc[0](Arg0: &mut RequestData)

57MutBorrowField[4](RequestData.discounts_applied: VecMap<String, u64>)

58MoveLoc[1](Arg1: String)

59MoveLoc[2](Arg2: u8)

60CastU64

61Call vec_map::insert<String, u64>(&mut VecMap<String, u64>, String, u64)

62Ret

}

target_expiration(Arg0: &Registry, Arg1: Domain, Arg2: &Clock, Arg3: u8): u64 {

L4: loc0: NameRecord

L5: loc1: Option<NameRecord>

B0:

0MoveLoc[0](Arg0: &Registry)

1MoveLoc[1](Arg1: Domain)

2Call registry::lookup(&Registry, Domain): Option<NameRecord>

3StLoc[5](loc1: Option<NameRecord>)

4ImmBorrowLoc[5](loc1: Option<NameRecord>)

5Call option::is_some<NameRecord>(&Option<NameRecord>): bool

6BrFalse(8)

B1:

7Branch(12)

B2:

8MoveLoc[2](Arg2: &Clock)

9Pop

10LdU64(13906835742006706181)

11Abort

B3:

12MoveLoc[5](loc1: Option<NameRecord>)

13Call option::destroy_some<NameRecord>(Option<NameRecord>): NameRecord

14StLoc[4](loc0: NameRecord)

15ImmBorrowLoc[4](loc0: NameRecord)

16MoveLoc[2](Arg2: &Clock)

17Call name_record::has_expired_past_grace_period(&NameRecord, &Clock): bool

18Not

19BrFalse(21)

B4:

20Branch(23)

B5:

21LdU64(13906835767776641031)

22Abort

B6:

23ImmBorrowLoc[4](loc0: NameRecord)

24Call name_record::expiration_timestamp_ms(&NameRecord): u64

25MoveLoc[3](Arg3: u8)

26CastU64

27Call constants::year_ms(): u64

28Mul

29Add

30Ret

}

Constants [

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

1 => vector<u8>: "Multiple discounts are not allowed" // interpreted as UTF8 string

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

3 => vector<u8>: "Renewal is not supported in this function call. Call `renew` instead." // interpreted as UTF8 string

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

5 => vector<u8>: "Tries to renew a name that does not exist in the registry (has expired + has been burned)" // interpreted as UTF8 string

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

7 => vector<u8>: "Tries to renew an expired name (post grace period)." // interpreted as UTF8 string

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

9 => vector<u8>: "The receipt domain does not match the domain of the NFT." // interpreted as UTF8 string

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

11 => vector<u8>: "Version mismatch. The payment intent is not of the correct version for this package." // interpreted as UTF8 string

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

13 => vector<u8>: "Discount range is [0, 100]." // interpreted as UTF8 string

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

15 => vector<u8>: "Cannot renew a subdomain using the payment system." // interpreted as UTF8 string

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

17 => vector<u8>: "This discount key has already been applied to the payment intent." // interpreted as UTF8 string

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

19 => vector<u8>: "Cannot exceed the maximum number of years." // interpreted as UTF8 string

]

}